Packman Build Service PMBS

pipewire-aptx.changes Changed

pipewire-aptx.spec Changed

pipewire-0.3.51.tar.gz/.gitlab-ci.yml -> pipewire-0.3.52.tar.gz/.gitlab-ci.yml Changed

pipewire-0.3.51.tar.gz/INSTALL.md -> pipewire-0.3.52.tar.gz/INSTALL.md Changed

pipewire-0.3.51.tar.gz/NEWS -> pipewire-0.3.52.tar.gz/NEWS Changed

@@ -1,3 +1,120 @@
+# PipeWire 0.3.52 (2022-06-09)
+
+This is a bugfix release that is API and ABI compatible with previous
+0.3.x releases.
+
+## Highlights
+  - Add 44.1KHz to allowed samplerates. The server can now switch by
+    default between 48KHz and 44.1KHz.
+  - Streams now allocate less resources.
+  - Fix some bugs that could make the server crash.
+  - Bluetooth now supports the LC3plus vendor codec.
+  - Many bugfixes and improvements.
+
+
+## PipeWire
+  - Add 44.1KHz to allowed samplerates.
+  - Avoid setting the locale.
+  - Avoid use-after-free when destroying a node from spa-node-factory.
+  - Avoid using reallocarray when not available.
+  - Set port alias is not otherwise set.
+
+## Modules
+  - Improve filter-chain parsing and error reporting. Handle empty
+    nodes. (#1950)
+  - Handle destroy of globals and factory in most modules. (#565)
+  - Add refcounts to client and resources to handle destroy of the
+    protocol. (#565)
+  - Handle global node.name in filter-chain and loopback again, use
+    it to construct unique stream names.
+  - Avoid a wrapped pw-node in the adapter. This reduces resources
+    allocated for streams.
+  - Fix a crash when module-x11-bell was unloaded. (#2392)
+  - Add a new module-pipe-tunnel that can write/read data from a
+    UNIX pipe.
+
+## Tools
+  - Fix DSD playback again in pw-cat.
+  - Add -n option to pw-loopback to set node names.
+  - Add -P option to pw-cat to pass properties to the stream.
+  - Support stdin/stdout in pw-cat. (#2387)
+  - pw-dump now also dumps object removal when monitoring. (#2426)
+
+## SPA
+  - Avoid duplicate param results in pw-dump for ports.
+  - Avoid endless loops in audioconvert for badly behaving client.
+    (#2359)
+  - Scale max-error in alsa based on quantum and avoid logging a warning
+    when starting.
+  - Improve debug of failed format conversion. (#2383)
+  - Handle offset in the audio dsp mixer inputs and clamp to the max
+    buffer size.
+  - Add option to disable locale support for JSON number conversion.
+  - Add support for Astro A20 Gen2.
+  - Fix some of the test sources, the flags were not set correctly.
+  - Add camera location as property in libcamera and let the session manager
+    Generate a localized description.
+  - Fix some crashes due to wrong vargar types in v4l2 controls. (#2400)
+  - Improve ALSA resync behaviour. (#2257)
+  - Add support for Komplete Audio 6 MK2.
+  - Improve loop cancel while iterating.
+  - Try not to mix surround channels and AUX channels. Make card with many
+    ports look better when not using the Pro Audio profile.
+  - Vulkan filters were added.
+
+## Bluetooth
+  - Add LC3plus vendor codec.
+  - Handle unsupported indicators better.
+  - Ensure multiple devices on an adapter use different codecs because one
+    endpoint can only be used by one device at a time.
+  - Fix bitpool control as a follower.
+  - Handle bluetooth errors better.
+  - Speed up bluetooth connection by only waiting for the profiles
+    supported by the adapter.
+  - The dummy AVRCP player is disabled by default because it seems to break
+    more devices than it fixes.
+
+## pulse-server
+  - Add initial stream latency property so that devices can be started
+    with a resonably accurate latency.
+  - Fix ringbuffer underrun case. (#2366)
+  - module-native-protocol-tcp now has a auth-anonymous option to give
+    full access to the clients.
+  - Report a node as being moved when it is still moving. This improves
+    compatibility with pasystray.
+  - Avoid overallocating message memory.
+  - Don't export NETWORK nodes in zeroconf. (#2384)
+  - Fix stride for TrueHD and DTSHD passthrough. (#2284)
+  - Make sure we don't send too small audio fragments. Fixes capture
+    from multiple tabs in Chrome. (#2418)
+  - Rework module handling some more.
+  - Use the new native module-pipe-tunnel for pipe-sink and pipe-source.
+  - Implement the STREAM_MOVED message when a stream got moved. (#2407)
+  - Fix a potential segfault when stopping the server and a TCP module
+    as still loaded.
+
+## ALSA
+  - Add support for updating sw_params at runtime, mostly the min-avail
+    param.
+  - Capture and playback nodes are now assumed to use a different clock and
+    will activate the adaptive resampler when linked. This assumption is
+    removed in Pro Audio mode. This provide a better experience out of the
+    box with most devices.
+
+## JACK
+  - Fix setting properties with PIPEWIRE_PROPS again.
+  - Don't use 64 bits atomic operations for sync_timeout. (#1867)
+  - Cleanup in error cases was improved, avoiding some crashes. (#2394)
+
+## GStreamer
+  - Fix pipewiresink in mode=provide. (#1980)
+  - Share memory into a new buffer in pipewiresrc to avoid buffer corruption.
+  - Fixes to the source and fd use.
+  - It is now possible to set client properties as well. (#1573)
+
+
+Older versions:
+
 # PipeWire 0.3.51 (2022-04-28)
 
 This is a bugfix release that is API and ABI compatible with previous
@@ -93,9 +210,6 @@
     IPC thread is blocking on the data thread.
   - Allocation errors in metadata are handled better.
 
-
-Older versions:
-
 # PipeWire 0.3.50 (2022-04-13)
 
 This is a bugfix release that is API and ABI compatible with previous

pipewire-0.3.51.tar.gz/doc/Doxyfile.in -> pipewire-0.3.52.tar.gz/doc/Doxyfile.in Changed

pipewire-0.3.51.tar.gz/doc/dma-buf.dox -> pipewire-0.3.52.tar.gz/doc/dma-buf.dox Changed

@@ -1,28 +1,28 @@
-/** \page page_dma_buf DMA-BUF sharing
+/** \page page_dma_buf DMA-BUF Sharing
 
 PipeWire supports sharing Direct Memory Access buffers (DMA-BUFs) between
 clients via the `SPA_DATA_DmaBuf` data type. However properly negotiating
 DMA-BUF support on both the producer and the consumer side require following
 a specific procedure. This page describes said procedure by using events and
 methods from the filter or stream API.
+
 Note: This article focuses mostly on DMA-BUF sharing from arbitrary devices,
 like discrete GPUs. For using DMA-BUFs created by v4l2 please refer to the
 corresponding paragraph.
 
-# Capability negotiations
+# Capability Negotiations
 
-The capability negotiation for DMA-BUFs is complicated by the fact, that a
+The capability negotiation for DMA-BUFs is complicated by the fact that a
 usable and preferred optimal modifier for a given format can only be
-determined by the allocator, which has to be invoked with the intersection
-of all supported modifiers of all clients. As a result the fixation of the
-modifier has to be delegated from PipeWire to the node responsible for
+determined by the allocator. This allocator has to be invoked with the intersection
+of all supported modifiers for every client. As a result, the fixation of the
+modifier is delegated from PipeWire to the node responsible for
 allocating the buffers.
 
 ## pw_stream_connect
 
 The stream parameters should contain two `SPA_PARAM_EnumFormat` objects for
-each format: the first one is used for DMA-BUFs, the second one for shared
-memory buffers as a fallback.
+each format: one for DMA-BUFs, one for shared memory buffers as a fallback.
 
 Query the list of all supported modifiers from your graphics API of choice.
 Add a `SPA_FORMAT_VIDEO_modifier` property to the first stream parameter with
@@ -40,7 +40,7 @@
 To prioritise DMA-BUFs place those `SPA_PARAM_EnumFormat` containing modifiers
 first, when emitting them to PipeWire.
 
-## param_changed hook
+## param_changed Hook
 
 When the `param_changed` hook is called for a `SPA_PARAM_Format` the client
 has to parse the `spa_pod` directly. Use
@@ -57,32 +57,32 @@
 announce sufficient capabilities or fallback to shared memory buffers when
 possible.
 
-### For consumers
+### For Consumers
 
 Use `spa_format_video_raw_parse` to get the format and modifier.
 
-### For producers
+### For Producers
 
 Producers have to handle two cases when it comes to modifiers wrt. to the
 previous announced capabilities: Using only the modifier-less API, only the
-modifier aware one, or supporting both.
+modifier-aware one, or supporting both.
 
 - modifier-less:
   In this case only the modifier `DRM_FORMAT_MOD_INVALID` was announced with
   the format.
   It is sufficient to check if the `SPA_PARAM_Format` contains the modifier
-  property as described above. Is that the case use DMA-BUFs for screen-sharing,
+  property as described above. If that is the case, use DMA-BUFs for screen-sharing,
   else fall back to SHM, if possible.
 - modifier-aware:
   In this case a list with all supported modifiers will be returned in the format.
   (using `DRM_FORMAT_MOD_INVALID` as the token for the modifier-less API).
   On the `param_changed` event check if the modifier key is present and has the flag
-  `SPA_POD_PROP_FLAG_DONT_FIXATE`. attached to it. In this case extract all modifiers
+  `SPA_POD_PROP_FLAG_DONT_FIXATE` attached to it. In this case, extract all modifiers
   from the list and do a test allocation with your allocator to choose the preferred
   modifier. Fixate on that `EnumFormat` by announcing a `SPA_PARAM_EnumFormat` with
   only one modifier in the `SPA_CHOICE_Enum` and without the
   `SPA_POD_PROP_FLAG_DONT_FIXATE` flag, followed by the previous announced
-  `EnumFormat`s. This will retrigger the `param_changed` event with an
+  `EnumFormat`. This will retrigger the `param_changed` event with an
   `SPA_PARAM_Format` as described below.
   If the `SPA_PARAM_Format` contains a modifier key, without the flag
   `SPA_POD_PROP_FLAG_DONT_FIXATE`, it should only contain one value in the
@@ -96,32 +96,32 @@
 possible modifiers contains `DRM_FORMAT_MOD_INVALID`, fall back to allocating
 without an explicit modifier if the graphics API allows it.
 
-## add_buffer hook
+## add_buffer Hook
 
 This is relevant for producers.
 
 Allocate a DMA-BUF only using the negotiated format and modifier.
 
-## on_event hook
+## on_event Hook
 
 This is relevant for consumers.
 
 Check the type of the dequeued buffer. If its `SPA_DATA_MemFd` or
 `SPA_DATA_MemPtr` use the fallback SHM import mechanism.
-If it's `SPA_DATA_DmaBuf`:
-Get the DMA-BUF FDs (the plane count is encoded in the `n_datas` variable of the
+If it's `SPA_DATA_DmaBuf` 
+get the DMA-BUF FDs (the plane count is encoded in the `n_datas` variable of the
 `spa_buffer` struct) and import them with the graphics API.
 
 Note: Some graphics APIs have separated functions for the modifier-less case
 (`DRM_FORMAT_MOD_INVALID`) or are omitting the modifier, since it might be used
 for error handling.
 
-## Example programs
+## Example Programs
 
 - \ref video-src-fixate.c "": \snippet{doc} video-src-fixate.c title
 - \ref video-play-fixate.c "": \snippet{doc} video-play-fixate.c title
 
-# DMA-BUF mapping warning
+# DMA-BUF Mapping Warning
 
 It's important to make sure all consumers of the PipeWire stream are prepared
 to deal with DMA-BUFs. Most DMA-BUFs cannot be treated like shared memory in general

pipewire-0.3.51.tar.gz/doc/index.dox -> pipewire-0.3.52.tar.gz/doc/index.dox Changed

@@ -1,37 +1,38 @@
 /** \mainpage PipeWire
 
 PipeWire is low-level multimedia framework that provides:
-  - Graph based processing
-  - Support for out-of-process processing graphs with minimal overhead
-  - Flexible and extensible media format negotiation and buffer allocation
-  - Hard real-time capable plugins
-  - Very low-latency for both audio and video processing
+
+- Graph based processing.
+- Support for out-of-process processing graphs with minimal overhead.
+- Flexible and extensible media format negotiation and buffer allocation.
+- Hard real-time capable plugins.
+- Very low-latency for both audio and video processing.
 
 See \ref page_overview for an overview of PipeWire and \ref page_design
 for the design principles guiding PipeWire.
 
-### Components
+# Components
 
 PipeWire ships with the following components:
 
-- a \ref page_daemon that implements the IPC and graph processing
-- an example \ref page_session_manager that manages objects in the \ref page_daemon
-- a set of \ref page_tools to introspect and use the \ref page_daemon
-- a \ref page_library to develop PipeWire applications and plugins (\ref
+- A \ref page_daemon that implements the IPC and graph processing.
+- An example \ref page_session_manager that manages objects in the \ref page_daemon.
+- A set of \ref page_tools to introspect and use the \ref page_daemon.
+- A \ref page_library to develop PipeWire applications and plugins (\ref
   page_tutorial "tutorial").
-- the \ref page_spa used by both the \ref page_daemon and in the \ref
+- The \ref page_spa used by both the \ref page_daemon and in the \ref
   page_library.
 
-### API Documentation
+# API Documentation
 
-See \ref page_api
+See \ref page_api.
 
-### More Documentation
+# More Documentation
 
 See our Wiki(https://gitlab.freedesktop.org/pipewire/pipewire/-/wikis/home) for
 More information on how to configure and use PipeWire.
 
-### Resources
+# Resources
 
 - PipeWire and AGL(https://wiki.automotivelinux.org/_media/pipewire_agl_20181206.pdf)
 - LAC 2020 Paper(https://lac2020.sciencesconf.org/307881/document)
@@ -39,4 +40,5 @@
 - PipeWire: The Linux audio/video bus (LWN)(https://lwn.net/Articles/847412)
 - PipeWire Wikipedia(https://en.wikipedia.org/wiki/PipeWire)
 - Bluetooth, PipeWire and Whatsapp calls(https://gjhenrique.com/pipewire.html)
+
 */

pipewire-0.3.51.tar.gz/doc/overview.dox -> pipewire-0.3.52.tar.gz/doc/overview.dox Changed

@@ -1,24 +1,24 @@
 /** \page page_overview Overview
 
 PipeWire is a new low-level multimedia framework designed from scratch that
-aims to provide
+aims to provide:
 
-- graph based processing
-- support for out-of-process processing graphs with minimal overhead
-- flexible and extensible media format negotiation and buffer allocation
-- Hard real-time capable plugins
-- achieve very low-latency for both audio and video processing
+- Graph based processing.
+- Support for out-of-process processing graphs with minimal overhead.
+- Flexible and extensible media format negotiation and buffer allocation.
+- Hard real-time capable plugins.
+- Achieve very low-latency for both audio and video processing.
 
 The framework is used to build a modular daemon that can be configured to:
 
-- be a low-latency audio server with features like pulseaudio and/or jack
-- a video capture server that can manage hardware video capture devices and
-  provide access to them
-- a central hub where video can be made available for other applications
+- Be a low-latency audio server with features like PulseAudio and/or JACK.
+- A video capture server that can manage hardware video capture devices and
+  provide access to them.
+- A central hub where video can be made available for other applications
   such as the gnome-shell screencast API.
 
 
-## Motivation
+# Motivation
 
 Linux has no unified framework for exchanging multimedia content between
 applications or even devices. In most cases, developers realized that
@@ -29,14 +29,14 @@
 - For video capture, we usually go directly to the hardware devices, with
   all security implications and inflexible routing that this brings.
 - For consumer audio, we use PulseAudio to manage and mix multiple streams
-  from clients
+  from clients.
 - For Pro audio, we use JACK to manage the graph of nodes.
 
-None of these solutions (except perhaps to some extent Wayland), however,
+None of these solutions (except perhaps to some extent Wayland) however 
 were designed to support the security features that are required when
 dealing with flatpaks or other containerized applications. PipeWire
 aims to solve this problem and provides a unified framework to run both
-consumer and Pro audio as well as video capture and processing in a
+consumer and pro audio as well as video capture and processing in a
 secure way.
 
 */

pipewire-0.3.51.tar.gz/doc/pipewire-access.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-access.dox Changed

@@ -14,46 +14,47 @@
   Some of those methods will only query state, others will modify the object.
   As said above, modifying the object through one of these methods requires
   the `W` permission.
-- `M`: An object with M permission can be used as the subject in metadata.
+- `M`: An object with `M` permission can be used as the subject in metadata.
 
 Clients with all permissions set are referred to as "ALL" in the
 documentation.
 
-# Use cases
 
-### New clients need their permissions configured
+# Use Cases
+
+## New Clients Need Their Permissions Configured
 
 A new client is not allowed to communicate with the PipeWire daemon until
 it has been configured with permissions.
 
-### Flatpaks can't modify other stream/device volumes
+## Flatpaks Can't Modify Other Stream/Device Volumes
 
 An application running as Flatpak should not be able to modify the state of
 certain objects. Permissions of the relevant PipeWire objects should not have
 the `W` permission to avoid this.
 
-### Flatpaks can't move other streams to different devices
+## Flatpaks Can't Move Other Streams To Different Devices
 
-Streams are moved to another device by setting the "target.node" metadata
-on the node id. By not setting the `M` bit on the other objects, this can be
+Streams are moved to another device by setting the `target.node` metadata
+on the node ID. By not setting the `M` bit on the other objects, this can be
 avoided.
 
-### Application should be restricted in what they can see
+## Application Should Be Restricted In What They Can See
 
 In general, applications should only be able to see the objects that they are
 allowed to see. For example, a web browser that was given access to a camera
 should not be able to see (and thus receive input data from) audio devices.
 
-### "Manager" applications require full access
+## "Manager" Applications Require Full Access
 
 Some applications require full access to the PipeWire graph, including
 moving streams between nodes (by setting metadata) and modifying properties
-(e.g. volume). These applications must work even when running as Flatpak.
+(eg. volume). These applications must work even when running as Flatpak.
 
 
 # Design
 
-## The PipeWire daemon
+## The PipeWire Daemon
 
 Immediately after a new client connects to the PipeWire daemon and updates
 its properties, the client will be registered and made visible to other
@@ -71,8 +72,7 @@
 sets the core permissions to `R`. This other client is usually a session
 manager, see e.g. \ref page_session_manager.
 
-
-## The PipeWire access module
+## The PipeWire Access Module
 
 The \ref page_module_access hooks into the `check_access` event that is
 emitted when a new client is registered. The module checks the permissions of
@@ -80,23 +80,23 @@
 property on the client object. If this property is already set, the access
 module does nothing.
 
-If the property is not set, it will go through a set of checks to determine
-the permissions for a client, see the \ref page_module_access documentation
+If the property is not set it will go through a set of checks to determine
+the permissions for a client. See the \ref page_module_access documentation
 for details, particularly on the values documented below. Depending on the
 value of the \ref PW_KEY_ACCESS property one the following happens:
 
 - `"allowed"`, `"unrestricted"`:  ALL permissions are set on the core
     object and the client will be able to resume.
-- `"restricted"`, `"flatpak"`, `"$access.force"`:  no permissions are set on
+- `"restricted"`, `"flatpak"`, `"$access.force"`:  No permissions are set on
     the core object and the client will be suspended.
-- `"rejected"`: an error is sent to the client and the client is
+- `"rejected"`: An error is sent to the client and the client is
     suspended.
 
 As detailed above, the client may be suspended. In that case the session
 manager or another client is required to configure permissions on the object
 for it to resume.
 
-## The session manager
+## The Session Manager
 
 The session manager listens for new clients to appear. It will use the
 \ref PW_KEY_ACCESS property to determine what to do.
@@ -117,7 +117,7 @@
 permission store checks or ask the user if the application is allowed
 full access.
 
-Manager applications (i.e. applications that need to modify the graph) will
+Manager applications (ie. applications that need to modify the graph) will
 set the \ref PW_KEY_MEDIA_CATEGORY property in the client object to "Manager".
 
 For details on the pipewire-media-session implementation of access control,

pipewire-0.3.51.tar.gz/doc/pipewire-audio.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-audio.dox Changed

@@ -2,19 +2,19 @@
 
 This document explains how Audio is implemented.
 
-# Use cases
+# Use Cases
 
-## Audio devices are made available as processing nodes/ports
+## Audio Devices Are Made Available As Processing Nodes/Ports
 
 Applications need to be able to see a port for each stream of an
-Audio device.
+audio device.
 
-### Audio devices can be plugged and unplugged
+## Audio Devices Can Be Plugged and Unplugged
 
 When devices are plugged and unplugged the associated nodes/ports
 need to be created and removed.
 
-### Audio port in canonical format
+## Audio Port In Canonical Format
 
 It must be possible to make individual audio channels available
 as a single mono stream with a fixed format and samplerate.
@@ -22,7 +22,7 @@
 This makes it possible to link any of the audio ports together
 without doing conversions.
 
-### Applications can connect to audio devices
+## Applications Can Connect To Audio Devices
 
 Applications can create ports that can connect to the audio ports
 so that data can be provided to or consumed from them.
@@ -30,19 +30,19 @@
 It should be possible to automatically connect an application to
 a sink/source when it requests this.
 
-### Default audio sink and sources
+## Default Audio Sink and Sources
 
 It should be possible to mark a source or sink as the default source
 and sink so that applications are routed to them by default.
 
 It should be possible to change the default audio sink/source.
 
-### Application should be able to move between sinks/sources
+## Application Should Be Able To Move Between Sinks/Sources
 
 It should be possible to move an application from one device to
 another dynamically.
 
-### Exclusive access
+## Exclusive Access
 
 Application should be able to connect to a device in exclusive mode.
 This allows the application to negotiate a specific format with the
@@ -62,13 +62,13 @@
 This object is then responsible for controlling the \ref spa_node "SPA Nodes" that
 provide the audio ports to interface with the device.
 
-The Nodes operate on the native audio formats supported by the device.
+The nodes operate on the native audio formats supported by the device.
 This includes the sample rate as well as the number of channels and
 the audio format.
 
 ## Audio Adapter
 
-An SPA Node called the "adapter" is usually used with the SPA device Node as
+An SPA Node called the "adapter" is usually used with the SPA device node as
 the internal node.
 
 The function of the adapter is to convert the device native format to
@@ -80,14 +80,14 @@
 
 The audio adapter can also be configured in passthrough mode when it
 will not do any conversions but simply pass through the port information
-of the internal Node. This can be used to implement exclusive access.
+of the internal node. This can be used to implement exclusive access.
 
 Setup of the different configurations of the adapter can be done with
 the PortConfig parameter.
 
-## The session manager
+## The Session Manager
 
-The session manager is responsible for creating Nodes and Ports for
+The session manager is responsible for creating nodes and ports for
 the various audio devices. It will need to wrap them into an audio
 adapter so that the specific configuration of the node can be
 decided by the policy mode.
@@ -96,33 +96,32 @@
 devices and nodes.
 
 The session manager is responsible for assigning priorities to the
-Nodes. At least \ref PW_KEY_PRIORITY_SESSION and \ref PW_KEY_PRIORITY_DRIVER
+nodes. At least \ref PW_KEY_PRIORITY_SESSION and \ref PW_KEY_PRIORITY_DRIVER
 need to be set.
 
 The session manager might need to work with other services to gain
-exclusive access to the device (e.g. DBus).
+exclusive access to the device (eg. DBus).
 
 
 # Implementation
 
-## pipewire-media-session (alsa-monitor)
+## PipeWire Media Session (alsa-monitor)
 
 PipeWire media session uses the \ref SPA_NAME_API_ALSA_ENUM_UDEV plugin
 for enumerating the ALSA devices. For each device it does:
 
 - Try to acquire the DBus device reservation object to gain exclusive
   access to the device.
-- Create an SPA Device instance for the device and monitor this device instance.
-- For each Node created by the device, create an adapter with
+- Create an SPA device instance for the device and monitor this device instance.
+- For each node created by the device, create an adapter with
   an ALSA PCM node in the context of the PipeWire daemon.
 
 The session manager will also create suitable names and descriptions
-for the Devices and Nodes that it creates as well as assign session
+for the devices and nodes that it creates as well as assign session
 and driver priorities.
 
 The session manager has the option to add extra properties on the
-Devices and Node that it creates to control their behavior. This
+devices and nodes that it creates to control their behavior. This
 is implemented with match rules.
 
-
 */

pipewire-0.3.51.tar.gz/doc/pipewire-daemon.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-daemon.dox Changed

@@ -7,7 +7,7 @@
 connections and manages devices. Clients (including the \ref
 page_session_manager) are separate processes that talk to the daemon using the
 PipeWire socket (default: `$XDG_RUNTIME_DIR/pipewire-0`). This approach
-provides provides address-space separation between the privileged daemon and
+provides address-space separation between the privileged daemon and
 non-privileged clients.
 
 \dot
@@ -52,7 +52,7 @@
 page_module_protocol_native. From PipeWire's point-of-view this module is just
 another module.
 
-\section sec_config Configuration Files
+# Configuration Files
 
 On startup, the daemon reads a configuration file to configure itself.
 It executes a series of commands listed in the config file. The lookup order
@@ -75,14 +75,14 @@
 and array elements are appended. This makes it possible to make small custom customizations
 or additions to the main configuration file.
 
-The environment variables `PIPEWIRE_CONFIG_DIR`, `PIPEWIRE_CONFIG_PREFIX`
-and `PIPEWIRE_CONFIG_NAME` can be used to specify an alternative config
-directory, subdirectory and filename, respectively.
+The environment variables `PIPEWIRE_CONFIG_DIR`, `PIPEWIRE_CONFIG_PREFIX`, 
+and `PIPEWIRE_CONFIG_NAME`. Can be used to specify an alternative configuration
+directory, subdirectory, and filename respectively.
 
-\subsection sec_config_format Configuration File Format
+## Configuration File Format
 
-PipeWire's configuration file format is JSON. In addition to true JSON,
-PipeWire also understands a more compact JSON representation where
+PipeWire's configuration file format is JSON. In addition to true JSON 
+PipeWire also understands a more compact JSON representation. Where
 `"` can be omitted around strings, no trailing commas are required and
 `:` or `=` can be used to separate object keys from their values.
 Also, `#` can be used to start a comment until the end of the line.
@@ -117,63 +117,60 @@
 
 - **context.properties**  (dictionary):   These   properties  configure  the
   pipewire instance.
-
 - **context.spa-libs** (dictionary): Maps plugin features with globs to a
   spa library.
-
 - **context.modules** (array): Each entry in the array is a dictionary with
   the name of the module to load, including optional args and flags. Most
   modules support being loaded multiple times.
-
 - **context.objects** (array):  Each entry in the array is a dictionary con‐
   taining the factory to create an object from and optional  extra  argu‐
   ments specific to that factory.
-
 - **context.exec**  (array): Each entry in the array is dictionary containing
   the path of a program to execute on startup and optional args. This ar‐
   ray usually contains an entry to start the session manager.
 
 
-\section sec_logging Logging
+# Logging
 
 The `PIPEWIRE_DEBUG` environment variable can be used to enable
 more debugging. This variable supports one of two formats:
 
-- `PIPEWIRE_DEBUG=<level>` where `<level>` is either a numerical log level or it's
+- `PIPEWIRE_DEBUG=<level>` where `<level>` is either a numerical log level or its
    respective key, see below.
 - `PIPEWIRE_DEBUG=<glob1>:<level1>,<glob2>:<level2>,...` where the globs are
-  shell-globs to match on log topics and the levels are the respective
-  log level to set for that topic. Globs are applied in-order and a matching
+  shell globs to match on log topics and the levels are the respective
+  log level to set for that topic. Globs are applied in order and a matching
   glob overrides an earlier glob for that category. For example,
-  `PIPEWIRE_DEBUG=*:E,mod.*:D,mod.foo:X" enables global error messages,
+  `PIPEWIRE_DEBUG=*:E,mod.*:D,mod.foo:X` enables global error messages,
   debugging on all modules but no messages on the foo module.
-
 - `<level>` specifies the log level:
-  + `X` or `0`: no logging is enabled
-  + `E` or `1`: Error logging is enabled
-  + `W` or `2`: Warnings are enabled
-  + `I` or `3`: Informational messages are enabled
-  + `D` or `4`: Debug messages are enabled
+
+  + `X` or `0`: No logging is enabled.
+  + `E` or `1`: Error logging is enabled.
+  + `W` or `2`: Warnings are enabled.
+  + `I` or `3`: Informational messages are enabled.
+  + `D` or `4`: Debug messages are enabled.
   + `T` or `5`: Trace messages are enabled. These messages can be logged
      	from the realtime threads.
 
-PipeWire uses a "category.topic" naming scheme, with the following categories:
-- `pw.*`: pipewire-internal topics
-- `mod.*`: module topics, for example `mod.foo` would usually refer to the
-  "foo" module
-- `ms.*`: media session topics
-- `ms.mod.*`: media session modules, for example `ms.foo` would usually refer
-   to the "media-session-foo" module
-- `conn.*`: connection-specific topics such as printing raw messages sent over
+PipeWire uses a `category.topic` naming scheme, with the following categories:
+
+- `pw.*`: PipeWire internal topics.
+- `mod.*`: Module topics, for example `mod.foo` would usually refer to the
+  `foo` module.
+- `ms.*`: Media session topics.
+- `ms.mod.*`: Media session modules, for example `ms.foo` would usually refer
+   to the `media-session-foo` module.
+- `conn.*`: Connection specific topics such as printing raw messages sent over
   a communication socket. These are in a separate namespace as they are
   usually vastly more verbose than the normal debugging topics.
   This namespace must be explicitly enabled with a `conn.<glob>` glob.
 
-
 The behavior of the logging can be further controlled with the following
 environment variables:
-- `PIPEWIRE_LOG_SYSTEMD=false`: disable logging to the systemd journal
-- `PIPEWIRE_LOG=<filename>`: redirect the log to the given filename
-- `PIPEWIRE_LOG_LINE=false`: don't log filename, function, and source code line
+
+- `PIPEWIRE_LOG_SYSTEMD=false`: Disable logging to the systemd journal.
+- `PIPEWIRE_LOG=<filename>`: Redirect the log to the given filename.
+- `PIPEWIRE_LOG_LINE=false`: Don't log filename, function, and source code line.
 
 */

pipewire-0.3.51.tar.gz/doc/pipewire-design.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-design.dox Changed

@@ -6,13 +6,13 @@
 Nodes can run inside the server process or in separate processes,
 communicating with the server.
 
-PipeWire was designed to
+PipeWire was designed to:
 
- - be efficient for raw video using fd passing and audio with
-   shared ringbuffers
- - be able to provide/consume/process media from any process
- - provide policy to restrict access to devices and streams
- - be easily extensible
+- Be efficient for raw video using fd passing and audio with
+  shared ringbuffers.
+- Be able to provide/consume/process media from any process.
+- Provide policy to restrict access to devices and streams.
+- Be easily extensible.
 
 Although an initial goal, the design is not limited to raw video
 only and should be able to handle compressed video and other
@@ -23,36 +23,30 @@
 format. SPA also provides a number of helper utilities that are not available
 in the standard C library.
 
-Some of the application we intend to build
+Some of the application we intend to build:
 
- - v4l2 device provider: Provide controlled access to v4l2 devices
-   and share one device between multiple processes.
+- v4l2 device provider: Provide controlled access to v4l2 devices
+  and share one device between multiple processes.
+- gnome-shell video provider: GNOME Shell provides a node that
+  gives the contents of the frame buffer for screen sharing or
+  screen recording.
+- Audio server: Mix and playback multiple audio streams. The design
+  is more like CRAS (Chromium audio server) than PulseAudio and with
+  the added benefit that processing can be arranged in a graph.
+- Professional audio graph processing like JACK.
+- Media playback backend.
 
- - gnome-shell video provider: GNOME Shell provides a node that
-   gives the contents of the frame buffer for screen sharing or
-   screen recording.
 
- - audio server: Mix and playback multiple audio streams. The design
-   is more like CRAS (Chromium audio server) than PulseAudio and with
-   the added benefit that processing can be arranged in a graph.
-
- - Pro audio graph processing like JACK.
-
- - Media playback backend
-
-
-Protocol
---------
+# Protocol
 
 The native protocol and object model is similar to
 Wayland(https://wayland.freedesktop.org) but with custom
-serialization/deserialization of messages. This is because the datastructures
+serialization/deserialization of messages. This is because the data structures
 in the messages are more complicated and not easily expressible in XML.
 See \ref page_module_protocol_native for details.
 
 
-Extensibility
--------------
+# Extensibility
 
 The functionality of the server is implemented and extended with modules and
 extensions. Modules are server side bits of logic that hook into various
@@ -64,16 +58,13 @@
 both a client side and server side init function. New interfaces or new object
 implementation can easily be added with modules/extensions.
 
-Some of the extensions that can be written
-
- - protocol extensions: a client/server side API (.h) together with protocol
-   extensions and server/client side logic to implement a new object or
-   interface.
-
- - a module to check security of method calls
-
- - a module to automatically create, link or relink nodes
+Some of the extensions that can be written:
 
- - a module to suspend idle nodes
+- Protocol extensions: A client/server side API (.h) together with protocol
+  extensions and server/client side logic to implement a new object or
+  interface.
+- A module to check security of method calls.
+- A module to automatically create, link or relink nodes.
+- A module to suspend idle nodes.
 
 */

pipewire-0.3.51.tar.gz/doc/pipewire-library.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-library.dox Changed

@@ -1,15 +1,15 @@
 /** \page page_library PipeWire Library
 
-There are 2 main components that make up the PipeWire library:
+There are two main components that make up the PipeWire library:
 
 1. An implementation of a graph based media processing engine.
 2. An asynchronous IPC mechanism to manipulate and introspect
-    a graph in another process.
+   a graph in another process.
 
 There is usually a daemon that implements the global graph and
 clients that operate on this graph.
 
-The IPC mechanism in PipeWire is inspired by wayland in that it
+The IPC mechanism in PipeWire is inspired by Wayland in that it
 follows the same design principles of objects and methods/events
 along with how this API is presented to the user.
 
@@ -18,7 +18,8 @@
 aspects of PipeWire and change the behaviour or number of
 features dynamically.
 
-## Principles
+
+# Principles
 
 The PipeWire API is an object oriented asynchronous protocol.
 All requests and replies are method invocations on some object.
@@ -51,7 +52,8 @@
 State about objects can be obtained by binding to them and listening
 for state changes.
 
-## Versioning
+
+# Versioning
 
 All interfaces have a version number. The maximum supported version
 number of an interface is advertized in the registry global event.
@@ -64,7 +66,8 @@
 are added. Methods or events should never be removed or changed for
 simplicity.
 
-## Proxies and resources
+
+# Proxies and Resources
 
 When a client connects to a PipeWire daemon, a new `struct pw_proxy`
 object is created with ID 0. The `struct pw_core` interface is
@@ -83,25 +86,22 @@
 proxy when it no longer wants to use it.
 
 
-## Interfaces
+# Interfaces
 
-### `struct pw_loop`
+## struct pw_loop
 
 An abstraction for a `poll(2)` loop. It is usually part of one of:
 
-* `struct pw_main_loop`: a helper that can run and stop a `pw_loop`.
-
-* `struct pw_thread_loop`: a helper that can run and stop a `pw_loop`
-		in a different thread. It also has some helper
-		functions for various thread related synchronization
-		issues.
-
-* `struct pw_data_loop`: a helper that can run and stop a `pw_loop`
-		in a real-time thread along with some useful helper
-		functions.
+- `struct pw_main_loop`: A helper that can run and stop a `pw_loop`.
+- `struct pw_thread_loop`: A helper that can run and stop a `pw_loop`
+  in a different thread. It also has some helper
+  functions for various thread related synchronization
+  issues.
+- `struct pw_data_loop`: A helper that can run and stop a `pw_loop`
+  in a real-time thread along with some useful helper
+  functions.
 
-
-### `struct pw_context`
+## struct pw_context
 
 The main context for PipeWire resources. It keeps track of the mainloop,
 loaded modules, the processing graph and proxies to remote PipeWire
@@ -113,8 +113,7 @@
 The context has methods to create the various objects you can use to
 build a server or client application.
 
-
-### `struct pw_core`
+## struct pw_core
 
 A proxy to a remote PipeWire instance. This is used to send messages
 to a remote PipeWire daemon and to receive events from it.
@@ -125,63 +124,63 @@
 Other core methods and events are used internally for the object
 life cycle management.
 
-### `struct pw_registry`
+## struct pw_registry
 
 A proxy to a PipeWire registry object. It emits events about the
 available objects on the server and can be used to bind to those
 objects in order to call methods or receive events from them.
 
-### `struct pw_module`
+## struct pw_module
 
 A proxy to a loadable module. Modules implement functionality such
 as provide new objects or policy.
 
-### `struct pw_factory`
+## struct pw_factory
 
 A proxy to an object that can create other objects.
 
-### `struct pw_device`
+## struct pw_device
 
 A proxy to a device object. Device objects model a physical hardware
 or software device in the system and can create other objects
 such as nodes or other devices.
 
-### `struct pw_node`
+## struct pw_node
 
 A Proxy to a processing node in the graph. Nodes can have input and
 output ports and the ports can be linked together to form a graph.
 
-### `struct pw_port`
+## struct pw_port
 
-A Proxy to an input or output port of a node.  They can be linked
+A Proxy to an input or output port of a node. They can be linked
 together to form a processing graph.
 
-### `struct pw_link`
+## struct pw_link
 
 A proxy to a link between in output and input port. A link negotiates
 a format and buffers between ports. A port can be linked to many other
 ports and PipeWire will manage mixing and duplicating the buffers.
 
 
-## High level helper objects
+# High Level Helper Objects
 
 Some high level objects are implemented to make it easier to interface
 with a PipeWire graph.
 
-### `struct pw_filter`
+## struct pw_filter
 
 A `struct pw_filter` allows you implement a processing filter that can
 be added to a PipeWire graph. It is comparable to a JACK client.
 
-### `struct pw_stream`
+## struct pw_stream
 
-a `struct pw_stream` makes it easy to implement a playback or capture
+A `struct pw_stream` makes it easy to implement a playback or capture
 client for the graph. It takes care of format conversion and buffer
 sizes. It is comparable to Core Audio AudioQueue or a PulseAudio
 stream.
 
 
-## Security
+# Security
 
 With the default native protocol, clients connect to PipeWire using
 a named socket. This results in a client socket that is used to
@@ -215,13 +214,14 @@
 and data between clients. Clients can thus not look at other clients
 data unless they can see the objects and connect to them.
 
-## Implementation
+
+# Implementation
 
 PipeWire also exposes an API to implement the server side objects in
 a graph.
 
 
-## Error reporting
+# Error Reporting
 
 Functions return either NULL with errno set or a negative int error
 code when an error occurs. Error codes are used from the SPA plugin
@@ -237,6 +237,4 @@
 callback). The sequence number can be used to see which operation
 completed.
 
-
 */
-

pipewire-0.3.51.tar.gz/doc/pipewire-midi.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-midi.dox Changed

@@ -2,41 +2,43 @@
 
 This document explains how MIDI is implemented.
 
-# Use cases
 
-### MIDI devices are made available as processing nodes/ports
+# Use Cases
+
+## MIDI Devices Are Made Available As Processing Nodes/Ports
 
 Applications need to be able to see a port for each stream of a
 MIDI device.
 
-### MIDI devices can be plugged and unplugged
+## MIDI Devices Can Be Plugged and Unplugged
 
 When devices are plugged and unplugged the associated nodes/ports
 need to be created and removed.
 
-### Applications can connect to MIDI devices
+## Applications Can Connect To MIDI Devices
 
 Applications can create ports that can connect to the MIDI ports
 so that data can be provided to or consumed from them.
 
-### Some MIDI devices are sinks or sources for midi data
+## Some MIDI Devices Are Sinks Or Sources For MIDI Data
 
 It should be possible to create a MIDI sink or source that routes the
-midi events to specific midi ports.
+MIDI events to specific MIDI ports.
 
-One example of such a sink would be in front of a software midi
+One example of such a sink would be in front of a software MIDI
 renderer.
 
 An example of a MIDI source would be after a virtual keyboard or
-as a mix from many midi input devices.
+as a mix from many MIDI input devices.
 
-### Applications should autoconnect to MIDI sinks or sources
+## Applications Should Auto-connect To MIDI Sinks Or Sources
 
 An application should be able to be connected to a MIDI sink when
-it wants to play midi data.
+it wants to play MIDI data.
 
 An application should be able to connect to a MIDI source when it
-wants to capture midi data.
+wants to capture MIDI data.
+
 
 # Design
 
@@ -48,7 +50,7 @@
 are of type \ref spa_pod_sequence with the \ref spa_pod_control type set to
 \ref SPA_CONTROL_Midi.
 
-This means that every midi event is timestamped with the sample
+This means that every MIDI event is timestamped with the sample
 offset against the current graph clock cycle to get sample accurate
 midi events that can be aligned with the corresponding sample data.
 
@@ -56,13 +58,13 @@
 they can be interleaved with other control message types, such as
 property updates or OSC messages.
 
-## The PipeWire daemon
+## The PipeWire Daemon
 
 Nothing special is implemented for MIDI. Negotiation of formats
 happens between `"application/control"` media types and buffers are
 negotiated in the same way as any generic format.
 
-## The session manager
+## The Session Manager
 
 The session manager needs to create the MIDI nodes/ports for the available
 devices.
@@ -76,10 +78,10 @@
 
 # Implementation
 
-## pipewire-media-session
+## PipeWire Media Session
 
 PipeWire media session uses the \ref SPA_NAME_API_ALSA_SEQ_BRIDGE plugin for
-the midi features. This creates a single SPA Node with ports per
+the MIDI features. This creates a single SPA Node with ports per
 MIDI client/stream.
 
 The media session will check the permissions on `/dev/snd/seq` before
@@ -88,7 +90,7 @@
 
 ## JACK
 
-JACK assumes all `"application/control"` ports are midi ports.
+JACK assumes all `"application/control"` ports are MIDI ports.
 
 The control messages are converted to the JACK event format by
 filtering out the \ref SPA_CONTROL_Midi types. On output ports, the JACK
@@ -98,5 +100,4 @@
 messages so there is no information loss or need for complicated
 conversions.
 
-
 */

pipewire-0.3.51.tar.gz/doc/pipewire-modules.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-modules.dox Changed

pipewire-0.3.51.tar.gz/doc/pipewire-objects-design.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-objects-design.dox Changed

@@ -1,11 +1,12 @@
 /** \page page_objects_design Objects Design
 
 This document is a design reference on the various objects that exist
-in the PipeWire media and session management graphs, explaining what these
-objects are, how they are meant to be used and how they relate to other
+in the PipeWire media and session management graphs. Explaining what these
+objects are, how they are meant to be used, and how they relate to other
 kinds of objects and concepts that exist in subsystems or other libraries.
 
-## The media graph
+
+# The Media Graph
 
 The media graph represents and enables the media flow inside the PipeWire
 daemon and between the daemon and its clients. It consists of nodes, ports
@@ -21,7 +22,7 @@
 +------------+                    +------------+
 ```
 
-### Node
+## Node
 
 A **node** is a media processing element. It consumes and/or produces buffers
 that contain data, such as audio or video.
@@ -33,26 +34,28 @@
 In an analogy to GStreamer, a _node_ is similar (but not equal) to a
 GStreamer _element_.
 
-### Port
+## Port
 
 A **port** is attached on a **node** and provides an interface for input
 or output of media on the node. A node may have multiple ports.
 
 A port always has a direction, input or output:
+
 - Input: it allows media input into the node (in other terms, it is a _sink_)
 - Output: it outputs media out of the node (in other terms, it is a _source_)
 
 In an analogy to GStreamer, a _port_ is similar (but not equal) to a
 GStreamer _pad_.
 
-### Link
+## Link
 
-A **link** connects 2 ports of opposite direction, making media flow from
+A **link** connects two ports of opposite direction, making media flow from
 the output port to the input port.
 
-## The session management graph
 
-The session management graph is a virtual, higher-level representation of the
+# The Session Management Graph
+
+The session management graph is a virtual, higher level representation of the
 media flow. It is created entirely by the session manager and it can affect
 the routing on the media graph only through the session manager's actions.
 
@@ -70,28 +73,31 @@
 +---------------------+                                +----------------------+
 ```
 
-### Endpoint
+## Endpoint
 
 An **endpoint** is a session management object that provides a representation
-of user-conceivable places where media can be routed to/from.
+of user conceivable places where media can be routed to/from.
 
 Examples of endpoints associated with hardware on a desktop-like system:
- - Laptop speakers
- - USB webcam
- - Bluetooth headset microphone
- - Line out stereo jack port
+
+- Laptop speakers.
+- USB webcam.
+- Bluetooth headset microphone.
+- Line out stereo jack port.
 
 Examples of endpoints associated with hardware in a car:
- - Speakers amplifier
- - Front right seat microphone array
- - Rear left seat headphones
- - Bluetooth phone voice gateway
- - Hardware FM radio device
+
+- Speakers amplifier.
+- Front right seat microphone array.
+- Rear left seat headphones.
+- Bluetooth phone voice gateway.
+- Hardware FM radio device.
 
 Examples of endpoints associated with software:
- - Desktop screen capture source
- - Media player application
- - Camera application
+
+- Desktop screen capture source.
+- Media player application.
+- Camera application.
 
 In most cases an endpoint maps to a node on the media graph, but this is not
 always the case. An endpoint may be backed by several nodes or no nodes at all.
@@ -107,7 +113,7 @@
 it and the amplifier, so that it can apply audio policy that takes into account
 whether the CD player is playing or not.
 
-#### Target
+### Target
 
 An **endpoint** may be grouping together targets that can be reached by
 following the same route and they are mutually exclusive with each other.
@@ -121,7 +127,7 @@
 same endpoint, using a parameter on the _endpoint_ object to allow the user
 to choose the target (if the hardware allows configuring this at all).
 
-### Endpoint Stream
+## Endpoint Stream
 
 An **endpoint stream** is attached to an **endpoint** and represents a logical
 path that can be taken to reach this endpoint, often associated with
@@ -129,45 +135,48 @@
 
 For example, the "Speakers amplifier" endpoint in a car might have the
 following streams:
- - _Music_: a path to play music;
-       the implementation will output this to all speakers, using the volume
-       that has been configured for the "Music" use case
- - _Voice_: a path to play a voice message, such as a navigation message or
-       feedback from a voice assistant; the implementation will output this
-       to the front speakers only, lowering the volume of the music (if any)
-       on these speakers at the same time
- - _Emergency_: a path to play an emergency situation sound (a beep,
-       or equivalent); the implementation will output this on all speakers,
-       increasing the volume to a factory-defined value if necessary (to ensure
-       that it is audible) while muting audio from all other streams at the
-       same time
+
+- _Music_: A path to play music;
+  the implementation will output this to all speakers, using the volume
+  that has been configured for the "Music" use case.
+- _Voice_: A path to play a voice message; such as a navigation message or
+  feedback from a voice assistant, the implementation will output this
+  to the front speakers only. Lowering the volume of the music (if any)
+  on these speakers at the same time.
+- _Emergency_: A path to play an emergency situation sound (a beep,
+  or equivalent); the implementation will output this on all speakers.
+  Increasing the volume to a factory defined value if necessary (to ensure
+  that it is audible) while muting audio from all other streams at the
+  same time.
 
 In another example, a microphone that can be used for activating a voice
 assistant might have the following streams:
- - _Capture_: a path to capture directly from the microphone; this can be used
-       by an application that listens for the assistant's wake-word in order
-       to activate the full voice recognition engine
- - _CaptureDelayed_: a path to capture with a constant delay (meaning that
-       starting capturing now will actually capture something that was spoken
-       a little earlier); this can be used by the full voice recognition engine,
-       allowing it to start after the wake-word has been spoken while capturing
-       audio that also includes the wake-word
+
+- _Capture_: A path to capture directly from the microphone; this can be used
+  by an application that listens for the assistant's wake-word in order
+  to activate the full voice recognition engine.
+- _CaptureDelayed_: A path to capture with a constant delay (meaning that
+  starting capturing now will actually capture something that was spoken
+  a little earlier); this can be used by the full voice recognition engine,
+  allowing it to start after the wake-word has been spoken while capturing
+  audio that also includes the wake-word.
 
 Endpoint streams may be mutually exclusive or they may used simultaneously,
 depending on the implementation.
 
 Endpoint streams may be implemented in many ways:
- - By plugging additional nodes in the media graph that link to the device node
-   (ex. a simple buffering node linked to an alsa source node could implement
-   the _CaptureDelayed_ stream in the above microphone example)
- - By using a different device node (ex. different ALSA device on the same card)
-   that has a special meaning for the hardware
- - By triggering switches on the hardware (ex. modify ALSA controls on the
-   same device)
 
-### Endpoint Link
+- By plugging additional nodes in the media graph that link to the device node
+  (ex. a simple buffering node linked to an alsa source node could implement
+  the _CaptureDelayed_ stream in the above microphone example).
+- By using a different device node (ex. different ALSA device on the same card)
+  that has a special meaning for the hardware.
+- By triggering switches on the hardware (ex. modify ALSA controls on the
+  same device).
+
+## Endpoint Link
 
-An **endpoint link** connects 2 streams from 2 different endpoints, creating
+An **endpoint link** connects two streams from two different endpoints, creating
 a logical representation of media flow between the endpoints.
 
 An **endpoint link** may be implemented by creating one or more _links_ in the
@@ -175,7 +184,7 @@
 resources to enable media flow, in case the flow does not pass through the
 media graph.
 
-#### Constructing
+### Constructing
 
 Constructing an **endpoint link** is done by asking the _endpoint stream_
 objects to prepare it. First, the source stream is asked to provide linking
@@ -185,40 +194,43 @@
 provided information.
 
 This mechanism allows stream implementations:
- - to prepare for linking, adjusting hardware paths if necessary
- - to check for stream linking compatibility; not all streams can be connected
-   to all others (ex. streams with media flow in the hardware cannot be linked
-   to streams that are backed by nodes in the media graph)
- - to provide implementation-specific information for linking; in the standard
-   case this is going to be a list of _ports_ to be linked in the media graph,
-   but in a hardware-flow case it can be any kind of hardware-specific detail
 
-## Other related objects
+- To prepare for linking, adjusting hardware paths if necessary.
+- To check for stream linking compatibility; not all streams can be connected
+  to all others (ex. streams with media flow in the hardware cannot be linked
+  to streams that are backed by nodes in the media graph).
+- To provide implementation specific information for linking; in the standard
+  case this is going to be a list of _ports_ to be linked in the media graph,
+  but in a hardware-flow case it can be any kind of hardware-specific detail.
+
+
+# Other Related Objects
 
-### Device
+## Device
 
 A **device** represents a handle to an underlying API that is used to create
 higher level objects, such as nodes, or other devices.
 
 Well-known devices include:
+
 | Device API | Description |
 | :---       | :---        |
-| alsa.pcm.device | A handle to an ALSA card (ex. `hw:0`, `hw:1`, etc) |
-| alsa.seq.device | A handle to an ALSA Midi device |
-| v4l2.device     | A handle to a V4L2 device (`/dev/video0`, `/dev/video1`, etc..) |
-| jack.device     | A JACK client, allowing PipeWire to slave to JACK for audio input/output |
+| alsa.pcm.device | A handle to an ALSA card (ex. `hw:0`, `hw:1`, etc). |
+| alsa.seq.device | A handle to an ALSA Midi device. |
+| v4l2.device     | A handle to a V4L2 device (`/dev/video0`, `/dev/video1`, etc..). |
+| jack.device     | A JACK client, allowing PipeWire to slave to JACK for audio input/output. |
 
 A device may have a _profile_, which allows the user to choose between
 multiple configurations that the device may be capable of having, or to simply
 turn the device _off_, which means that the handle is closed and not used
 by PipeWire.
 
-### Session
+## Session
 
 The **session** represents the session manager and can be used to expose
 global properties or methods that affect the session management.
 
-#### Default endpoints
+### Default Endpoints
 
 The session is responsible for book-keeping the default device endpoints (one
 for each kind of device) that is to be used to link new clients when
@@ -227,17 +239,18 @@
 
 For example, a system may have both "Speakers" and "HDMI" endpoints on the
 "Audio Output" category and the user may be offered to make a choice within
-the UI to select which endpoint she wants to use by default for audio output.
+the UI to select which endpoint they want to use by default for audio output.
 This preference is meant to be stored in the session object.
 
-#### Multiple sessions
+### Multiple Sessions
 
 It is not currently defined whether it is allowed to have multiple sessions
 or not and how the system should behave if this happens.
 
-## Mappings to underlying subsystem objects
 
-### ALSA UCM
+# Mappings To Underlying Subsystem Objects
+
+## ALSA UCM
 
 This is a ***proposal***
 
@@ -252,15 +265,15 @@
 In UCM mode, an ALSA card is represented as a PipeWire device, with the
 available UCM verbs listed as profiles of the device.
 
-Activating a profile (i.e. a verb) will create the necessary nodes for the
+Activating a profile (ie. a verb) will create the necessary nodes for the
 available PCM streams and at the same time it will also create one endpoint
-for each UCM device. Optionally, conflicting UCM devices can be grouped in
+for each UCM device. Optionally conflicting UCM devices can be grouped in
 the same endpoint, listing the conflicting options as targets of the endpoint.
 
 The available UCM modifiers for each UCM device will be added as streams, plus
 one "default" stream for accessing the device with no modifiers.
 
-### ALSA fallback
+## ALSA Fallback
 
 | ALSA | PipeWire |
 | :--- | :---     |
@@ -268,15 +281,15 @@
 | PCM stream | node + endpoint |
 
 In the case where UCM (or another similar mechanism) is not available,
-ALSA cards are represented as PipeWire devices with only 2 profiles: On/Off
+ALSA cards are represented as PipeWire devices with only two profiles on/off.
 
-When the On profile is activated, a node and an associated endpoint are created
+When the on profile is activated, a node and an associated endpoint are created
 for every available PCM stream.
 
 Endpoints in this case have only one "default" stream, unless they are extended
 by the session manager to have software-backed streams.
 
-### V4L2
+## V4L2
 
 ***FIXME***
 
@@ -284,11 +297,12 @@
 | :--- | :---     |
 | device | device + node |
 
-## Relationship to other APIs
 
-### PulseAudio
+# Relationship To Other API's
+
+## PulseAudio
 
-#### Mapping PipeWire objects for access by PulseAudio clients
+### Mapping PipeWire Objects For Access By PulseAudio Clients
 
 | PipeWire | PulseAudio |
 | :---     | :---       |
@@ -297,21 +311,21 @@
 | endpoint (associated with a device) | sink / source |
 | endpoint (associated with a client) | sink-input / source-output |
 | endpoint target                     | port |
-| endpoint stream                     | N/A, pa clients will be limited to the default stream |
+| endpoint stream                     | N/A, PA clients will be limited to the default stream |
 
-#### Mapping PulseAudio clients to PipeWire
+### Mapping PulseAudio Clients To PipeWire
 
 | PulseAudio | PipeWire |
 | :---       | :---     |
 | stream     | client + node + endpoint (no targets, 1 default stream) |
 
-### Jack
+## Jack
 
 Note: This section is about JACK clients connecting to PipeWire through the
 JACK compatibility library. The scenario where PipeWire connects to another
 JACK server as a client is out of scope here.
 
-#### Mapping PipeWire objects for access by JACK clients
+### Mapping PipeWire Objects For Access By JACK Clients
 
 | PipeWire | JACK |
 | :---     | :--- |
@@ -320,7 +334,7 @@
 | device   | N/A    |
 | endpoint | N/A    |
 
-#### Mapping JACK clients to PipeWire
+### Mapping JACK Clients To PipeWire
 
 | JACK | PipeWire |
 | :--- | :---     |
@@ -328,6 +342,6 @@
 | port   | port |
 
 JACK clients do not create endpoints. A session manager should be JACK aware
-in order to anticipate direct node linking
+in order to anticipate direct node linking.
 
 */

pipewire-0.3.51.tar.gz/doc/pipewire-portal.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-portal.dox Changed

@@ -12,13 +12,14 @@
 client is a portal-managed client. PipeWire can detect and enforce
 extra permission checks on the portal managed clients.
 
-Once such portal is the Camera
+Once such portal is the camera
 portal(https://flatpak.github.io/xdg-desktop-portal/portal-docs.html#gdbus-org.freedesktop.portal.Camera)
 that provides a PipeWire session to stream video from a camera.
 
-# Use cases
 
-### new portal managed clients need device permissions configured
+# Use Cases
+
+## New Portal Managed Clients Need Device Permissions Configured
 
 When a new client is detected, the available objects need to be
 scanned and permissions configured for each of them.
@@ -26,7 +27,7 @@
 Only the devices belonging to the media_roles given by the
 portal are considered.
 
-### new devices need to be made visible to portal managed clients
+## New Devices Need To Be Made Visible To Portal Managed Clients
 
 Newly created objects are made visible to a client when the client
 is allowed to interact with it.
@@ -34,7 +35,7 @@
 Only the devices belonging to the media_roles given by the
 portal are considered.
 
-### permissions for a device need to be revoked
+## Permissions For A Device Need To Be Revoked
 
 The session manager listens to changes in the permissions of devices
 and will remove the client permissions accordingly.
@@ -46,7 +47,7 @@
 
 # Design
 
-## The portal
+## The Portal
 
 A sandboxed client cannot connect to PipeWire directly. Instead, it connects
 to the sandbox side of the portal which then connects the PipeWire daemon to
@@ -59,7 +60,7 @@
 
 - `"pipewire.access.portal.is_portal" = true` for the connection of the
   portal itself (as opposed to a client managed by the portal).
-- `"pipewire.access.portal.app_id"` the application id(https://docs.flatpak.org/en/latest/conventions.html#application-ids) of the client.
+- `"pipewire.access.portal.app_id"` the application ID(https://docs.flatpak.org/en/latest/conventions.html#application-ids) of the client.
 - `"pipewire.access.portal.media_roles"` media roles of the client.
   Currently only `"Camera"` is defined.
 
@@ -69,9 +70,9 @@
 visible, depending on the client's `media_roles` (see also \ref
 PW_KEY_MEDIA_ROLE).
 
-## The PipeWire portal module
+## The PipeWire Portal Module
 
-The pipewire daemon uses the \ref page_module_portal to find the PID of the
+The PipeWire daemon uses the \ref page_module_portal to find the PID of the
 processes that owns the DBus name `org.freedesktop.portal.Desktop`
 (see the XDG Desktop Portal(https://github.com/flatpak/xdg-desktop-portal)).
 
@@ -99,7 +100,7 @@
 }
 \enddot
 
-## The client
+## The Client
 
 A client can ask the portal for a connection to the PipeWire daemon.
 
@@ -145,7 +146,6 @@
 }
 \enddot
 
-
 The file descriptor for this restricted connection is passed back to the
 client which can now make use of the resources it has been permitted to
 access.
@@ -169,7 +169,7 @@
 }
 \enddot
 
-## The session manager
+## The Session Manager
 
 The session manager listens for new clients to appear. It will use the
 \ref PW_KEY_ACCESS property to find portal connections. For client connections

pipewire-0.3.51.tar.gz/doc/pipewire-session-manager.dox -> pipewire-0.3.52.tar.gz/doc/pipewire-session-manager.dox Changed

@@ -6,38 +6,41 @@
 It provides the mechanism to do so but the policy deciding which components
 can talk to each other and when is controlled by the session manager.  As
 outlined in \ref page_objects_design, PipeWire provides a media graph
-consistent of Devices, Nodes and Ports. The session manager is the one that
+consisting of devices, nodes and ports. The session manager is the one that
 decides on the links between those elements.
 
 Two prominent session managers currently exist:
+
 - PipeWire Media Session(https://gitlab.freedesktop.org/pipewire/media-session), the
-example session manager
+example session manager.
 - WirePlumber(https://gitlab.freedesktop.org/pipewire/wireplumber), a
-modular session manager based on GObject
+modular session manager based on GObject. 
+Documentation(https://pipewire.pages.freedesktop.org/wireplumber/)
 
 This page describes some of the requirements for session managers in general.
 
-## Client management
+
+# Client Management
 
 PipeWire provides a \ref page_access "permission system" to limit client's
 access to resources but only \ref page_module_access "basic permission
 handling". The session manager is expected to decide whether clients may
 access specific resources.
 
-## Device management
+
+# Device Management
 
 PipeWire's responsibility is to open devices, however the decision on which
 devices should be opened is the job of a session manager, including the
 configuration of those devices.
 
 
-## Endpoint grouping
+# Endpoint Grouping
 
-An endpoint is, effectively, a group of Nodes that are a logical unit that can
+An endpoint is, effectively, a group of nodes that are a logical unit that can
 consume or produce media data. For example, a Bluetooth speaker may present as
-several Nodes but is only one logical unit to stream audio to.
+several nodes but is only one logical unit to stream audio to.
 
 See \ref page_objects_design for details on Endpoints.
 
 */
-

pipewire-0.3.51.tar.gz/doc/pipewire.dox -> pipewire-0.3.52.tar.gz/doc/pipewire.dox Changed

pipewire-0.3.51.tar.gz/doc/pulseaudio.dox -> pipewire-0.3.52.tar.gz/doc/pulseaudio.dox Changed

@@ -1,18 +1,18 @@
-/** \page page_pulseaudio  PulseAudio compatibility
+/** \page page_pulseaudio PulseAudio Compatibility
 
-# Internals - Mapping between ALSA and streams
+# Internals - Mapping Between ALSA and Streams
 
 This explains the mapping between alsa cards and streams and session manager
 objects.
 
-
 ## ALSA Cards
 
-An ALSA card is exposed as a PipeWire device
+An ALSA card is exposed as a PipeWire device.
 
 ## Streams
 
-Each alsa PCM is opened and a Node is created for each PCM stream.
+Each ALSA PCM is opened and a node is created for each PCM stream.
+
 
 # Session Manager
 
@@ -22,8 +22,8 @@
 
 One PipeWire device is created for every ALSA card.
 
-For each UCM verb, a Node is created for the associated PCM devices.
-For each UCM verb, an Endpoint is created.
+- For each UCM verb, a node is created for the associated PCM devices.
+- For each UCM verb, an endpoint is created.
 
 In a first step: For each available combination of UCM device and modifier,
 a stream is created. Streams are marked with compatible other streams.
@@ -31,26 +31,23 @@
 Streams with the same modifier and mutually exclusive devices are grouped
 into one stream and the UCM devices are exposed on the endpoint as destinations.
 
-
-## ALSA fallback
+## ALSA Fallback
 
 Each PCM stream (node) becomes an endpoint. The endpoint references the
-alsa device id
+ALSA device ID.
 
-Each endpoint has 1 stream (for now) called HiFi Playback / HiFi Capture.
+Each endpoint has one stream (for now) called HiFi Playback / HiFi Capture.
 
 More streams can be created depending on the format of the node.
 
+## ALSA Pulse UCM
 
-## ALSA pulse UCM
-
-Using the alsa backend of pulseaudio we can create the following streams
-
+Using the ALSA backend of PulseAudio we can create the following streams.
 
-## ALSA pulse fallback
+## ALSA Pulse Fallback
 
-The pulse alsa backend will use the mixer controls and some probing to
-create the following nodes and endpoints
+The pulse ALSA backend will use the mixer controls and some probing to
+create the following nodes and endpoints.
 
 
 # PulseAudio
@@ -58,14 +55,14 @@
 PulseAudio uses the session manager API to construct cards with profiles
 and sink/source with ports.
 
-If an Endpoint references a Device, a card object is created for the device.
+If an endpoint references a device, a card object is created for the device.
 
-Each Endpoint becomes a sink/source.
+Each endpoint becomes a sink/source.
 
 Each Stream in the endpoint becomes a profile on the PulseAudio card. Because
-only one profile is selected on the device, only 1 stream is visible on
+only one profile is selected on the device, only one stream is visible on
 the endpoint. This clashes with the notion that multiple streams can be
-active at the same time but is a pulseaudio limitation.
+active at the same time but is a PulseAudio limitation.
 
 Each Endpoint destination becomes a port on the sink/source.

pipewire-0.3.51.tar.gz/doc/spa-buffer.dox -> pipewire-0.3.52.tar.gz/doc/spa-buffer.dox Changed

pipewire-0.3.51.tar.gz/doc/spa-design.dox -> pipewire-0.3.52.tar.gz/doc/spa-design.dox Changed

pipewire-0.3.51.tar.gz/doc/spa-index.dox -> pipewire-0.3.52.tar.gz/doc/spa-index.dox Changed

@@ -5,30 +5,34 @@
 
 It is inspired by many other plugin APIs, mostly LV2 and
 GStreamer. SPA provides two parts:
-- a header-only API with no external dependencies
-- a set of support libraries ("plugins") for commonly used functionality
+
+- A header-only API with no external dependencies.
+- A set of support libraries ("plugins") for commonly used functionality.
 
 The usual approach is that PipeWire and PipeWire clients can use the
 header-only functions to interact with the plugins. Those plugins are
-usually loaded at runtime (through `dlopen(3)`.
+usually loaded at runtime (through `dlopen(3)`).
+
 
-## Motivation
+# Motivation
 
 SPA was designed with the following goals in mind:
-- No dependencies, SPA is shipped as a set of header files that have no dependencies except for the standard c library.
+
+- No dependencies, SPA is shipped as a set of header files that have no dependencies except for the standard C library.
 - Very efficient both in space and in time.
 - Very configurable and usable in many different environments. All aspects
   of the plugin environment can be configured and changed, like logging,
-  poll loops, system calls etc.
-- Consistent API
-- Extensible, new API can be added with minimal effort, existing API can be updated and versioned.
+  poll loops, system calls, etc.
+- Consistent API.
+- Extensible; new API can be added with minimal effort, existing API can be updated and versioned.
 
 The original user of SPA is PipeWire, which uses SPA to implement the
 low-level multimedia processing plugins, device detection, mainloops, CPU
-detection and logging, among other things. SPA however can be used outside
+detection, logging, among other things. SPA however can be used outside
 of PipeWire with minimal problems.
 
-## The SPA header-only API
+
+# The SPA Header-Only API
 
 A very simple example on how SPA headers work are the \ref spa_utils, a set
 of utilities commonly required by C projects. SPA functions use the `spa_`
@@ -53,7 +57,7 @@
 \endcode
 
 
-## SPA Plugins
+# SPA Plugins
 
 SPA plugins are shared libraries (`.so` files) that can be loaded at
 runtime. Each library provides one or more "factories", each of which may
@@ -68,7 +72,7 @@
 Please see \ref page_spa_plugins for the details on how to use SPA plugins.
 
 
-## Further details
+# Further details
 
 - \ref api_spa
 - \subpage page_spa_design

pipewire-0.3.51.tar.gz/doc/spa-plugins.dox -> pipewire-0.3.52.tar.gz/doc/spa-plugins.dox Changed

@@ -3,19 +3,21 @@
 \ref spa_handle "SPA plugins" are dynamically loadable objects that contain objects and interfaces that
 can be introspected and used at runtime in any application. This document
 introduces the basic concepts of SPA plugins. It first covers using the API
-and then talks about implementing new Plugins.
+and then talks about implementing new plugins.
 
 
-## Outline
+# Outline
 
 To use a plugin, the following steps are required:
-- **load** the shared library
-- **enumerate** the available factories
-- **enumerate** the interfaces in each factory
-- **instantiate** the desired interface
-- **use** the interface-specific functions
+
+- **Load** the shared library.
+- **Enumerate** the available factories.
+- **Enumerate** the interfaces in each factory.
+- **Instantiate** the desired interface.
+- **Use** the interface-specific functions.
 
 In pseudo-code, loading a logger interface looks like this:
+
 \code{.py}
 handle = dlopen("$SPA_PLUGIN_PATH/support/libspa-support.so")
 factory_enumeration_func = dlsym(handle, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)
@@ -71,18 +73,18 @@
 \endverbatim
 
 
-## Open a plugin
+# Open A Plugin
 
 A plugin is opened with a platform specific API. In this example we use
 `dlopen()` as the method used on Linux.
 
-A plugin always consists of 2 parts, the vendor path and then the .so file.
+A plugin always consists of two parts, the vendor path and then the .so file.
 
 As an example we will load the "support/libspa-support.so" plugin. You will
-usually use some mapping between functionality and plugin path, as we'll see
+usually use some mapping between functionality and plugin path as we'll see
 later, instead of hardcoding the plugin name.
 
-To dlopen a plugin we then need to prefix the plugin path like this:
+To `dlopen` a plugin we then need to prefix the plugin path like this:
 
 \code{.c}
 #define SPA_PLUGIN_PATH	/usr/lib64/spa-0.2/"
@@ -105,7 +107,8 @@
 
 If this symbol is not available, the library is not a valid SPA plugin.
 
-## Enumerating factories
+
+# Enumerating Factories
 
 With the `enum_func` we can now enumerate all the factories in the plugin:
 
@@ -126,7 +129,7 @@
 
 We can enumerate the interfaces that we will find on this new object with
 the `spa_handle_factory_enum_interface_info()` method. Interface types
-are simple strings that uniquely define the interface (See also the type
+are simple strings that uniquely define the interface (see also the type
 system).
 
 The name of the factory is a well-known name that describes the functionality
@@ -142,7 +145,8 @@
 Usually the name will be mapped to a specific plugin. This way an
 alternative compatible implementation can be made in a different library.
 
-## Making a handle
+
+# Making A Handle
 
 Once we have a suitable factory, we need to allocate memory for the object
 it can create. SPA usually does not allocate memory itself but relies on
@@ -173,10 +177,11 @@
 
 The support parameter is an array of `struct spa_support` items. They
 contain a string type and a pointer to extra support objects. This can
-be a logging API or a main loop API, for example. Some plugins require
+be a logging API or a main loop API for example. Some plugins require
 certain support libraries to function.
 
-## Retrieving an interface
+
+# Retrieving An Interface
 
 When a SPA handle is made, you can retrieve any of the interfaces that
 it provides:
@@ -195,7 +200,7 @@
 \endcode
 
 
-## Clearing an object
+# Clearing An Object
 
 After you are done with a handle you can clear it with
 `spa_handle_clear()` and you can unload the library with `dlclose()`.
@@ -215,7 +220,7 @@
 
 Interfaces are defined in a header file (for example see
 `<spa/support/log.h>` for the logger API). It is a self contained
-definition that you can just use in your application after you dlopen()
+definition that you can just use in your application after you `dlopen()`
 the plugin.
 
 Some interfaces also provide extra fields in the interface, like the
@@ -223,7 +228,8 @@
 
 See \ref spa_interface for some implementation details on interfaces.
 
-## SPA Events
+
+# SPA Events
 
 Some interfaces will also allow you to register a callback (a hook or
 listener) to be notified of events. This is usually when something
@@ -270,7 +276,8 @@
 spa_hook_remove(&listener);
 \endcode
 
-## API results
+
+# API Results
 
 Some interfaces provide API that gives you a list or enumeration of
 objects/values. To avoid allocation overhead and ownership problems,
@@ -280,8 +287,7 @@
 problems. The application can look at the pushed result and keep/copy
 only what it wants to keep.
 
-
-### Synchronous results
+## Synchronous Results
 
 Here is an example of enumerating parameters on a node interface.
 
@@ -319,8 +325,7 @@
 spa_hook_remove(&listener);
 \endcode
 
-
-### Asynchronous results
+## Asynchronous Results
 
 Asynchronous results are pushed to the application in the same way as
 synchronous results, they are just pushed later. You can check that
@@ -342,9 +347,9 @@
 expected_seq = SPA_RESULT_ASYNC_SEQ(res);
 \endcode
 
-# Implementing a new plugin
+# Implementing A New Plugin
 
-FIXME
+***FIXME***

pipewire-0.3.51.tar.gz/doc/spa-pod.dox -> pipewire-0.3.52.tar.gz/doc/spa-pod.dox Changed

@@ -3,52 +3,54 @@
 \ref spa_pod (plain old data) is a sort of data container. It is comparable to
 DBus Variant or LV2 Atom.
 
-A POD can express nested structures of Objects (with properties), Vectors,
-Arrays, sequences and various primitives types. All information in the POD
+A POD can express nested structures of objects (with properties), vectors,
+arrays, sequences and various primitives types. All information in the POD
 is laid out sequentially in memory and can be written directly to
 storage or exchanged between processes or threads without additional
 marshalling.
 
 Each POD is made of a 32 bits size followed by a 32 bits type field,
-followed by the pod contents. This makes it possible to skip over unknown
+followed by the POD contents. This makes it possible to skip over unknown
 POD types. The POD start is always aligned to 8 bytes.
 
-PODs can be efficiently constructed and parsed in real-time threads without
+POD's can be efficiently constructed and parsed in real-time threads without
 requiring memory allocations.
 
-PODs use the SPA type system for the basic types and containers. See
+POD's use the SPA type system for the basic types and containers. See
 the SPA types for more info.
 
-## Types
 
-PODs can contain a number of basic SPA types:
+# Types
 
- - `SPA_TYPE_None`: no value or a NULL pointer.
- - `SPA_TYPE_Bool`: a boolean value
- - `SPA_TYPE_Id`: an enumerated value
- - `SPA_TYPE_Int`, `SPA_TYPE_Long`, `SPA_TYPE_Float`, `SPA_TYPE_Double`:
- -      	various numeral types, 32 and 64 bits.
- - `SPA_TYPE_String`: a string
- - `SPA_TYPE_Bytes`: a byte array
- - `SPA_TYPE_Rectangle`: a rectangle with width and height
- - `SPA_TYPE_Fraction`: a fraction with numerator and denominator
- - `SPA_TYPE_Bitmap`: an array of bits
+POD's can contain a number of basic SPA types:
 
-PODs can be grouped together in these container types:
+- `SPA_TYPE_None`: No value or a NULL pointer.
+- `SPA_TYPE_Bool`: A boolean value.
+- `SPA_TYPE_Id`: An enumerated value.
+- `SPA_TYPE_Int`, `SPA_TYPE_Long`, `SPA_TYPE_Float`, `SPA_TYPE_Double`:
+  various numeral types, 32 and 64 bits.
+- `SPA_TYPE_String`: A string.
+- `SPA_TYPE_Bytes`: A byte array.
+- `SPA_TYPE_Rectangle`: A rectangle with width and height.
+- `SPA_TYPE_Fraction`: A fraction with numerator and denominator.
+- `SPA_TYPE_Bitmap`: An array of bits.
 
- - `SPA_TYPE_Array`: an array of equal sized objects
- - `SPA_TYPE_Struct`: a collection of types and objects
- - `SPA_TYPE_Object`: an object with properties
- - `SPA_TYPE_Sequence`: a timed sequence of PODs
+POD's can be grouped together in these container types:
 
-PODs can also contain some extra types:
+- `SPA_TYPE_Array`: An array of equal sized objects.
+- `SPA_TYPE_Struct`: A collection of types and objects.
+- `SPA_TYPE_Object`: An object with properties.
+- `SPA_TYPE_Sequence`: A timed sequence of POD's.
 
- - `SPA_TYPE_Pointer`: a typed pointer in memory
- - `SPA_TYPE_Fd`: a file descriptor
- - `SPA_TYPE_Choice`: a choice of values
- - `SPA_TYPE_Pod`: a generic type for the POD itself
+POD's can also contain some extra types:
 
-# Constructing a POD
+- `SPA_TYPE_Pointer`: A typed pointer in memory.
+- `SPA_TYPE_Fd`: A file descriptor.
+- `SPA_TYPE_Choice`: A choice of values.
+- `SPA_TYPE_Pod`: A generic type for the POD itself.
+
+
+# Constructing A POD
 
 A POD is usually constructed with a `struct spa_pod_builder`. The builder
 needs to be initialized with a memory region to write into. It is
@@ -59,7 +61,7 @@
 estimated pretty easily and if the buffer is not large enough, an
 appropriate error will be generated.
 
-The code fragment below initializes a pod builder to write into
+The code fragment below initializes a POD builder to write into
 the stack allocated buffer.
 
 \code{.c}
@@ -96,7 +98,7 @@
 `spa_pod_builder_pop()` returns a reference to the object we completed
 on the stack.
 
-## Using varargs builder.
+## Using varargs Builder
 
 We can also use the following construct to make POD objects:
 
@@ -116,10 +118,10 @@
 	SPA_POD_Float(3.1415f));
 \endcode
 
-It's not possible to use the varargs builder to make a Sequence or
-Array, use the normal builder methods for that.
+It's not possible to use the varargs builder to make a sequence or
+array, use the normal builder methods for that.
 
-## Making objects
+## Making Objects
 
 POD objects are containers for properties and are comparable to JSON
 objects.
@@ -131,7 +133,7 @@
 \endcode
 
 An object requires an object type (`SPA_TYPE_OBJECT_Props`) and a context
-id (`SPA_PARAM_Props`). The object type defines the properties that can be
+ID (`SPA_PARAM_Props`). The object type defines the properties that can be
 added to the object and their meaning. The SPA type system allows you to
 make this connection (See the type system).
 
@@ -163,23 +165,23 @@
 	SPA_PROP_frequency, SPA_POD_Float(440.0f));
 \endcode
 
-## Choice values
+## Choice Values
 
 It is possible to express ranges or enumerations of possible
 values for properties (and to some extend structs). This is achieved
-with Choice values.
+with choice values.
 
 Choice values are really just a choice type and an array of choice values
 (of the same type). Depending on the choice type, the array values are
 interpreted in different ways:
 
- * `SPA_CHOICE_None`:   no choice, first value is current
- * `SPA_CHOICE_Range`:  range: default, min, max
- * `SPA_CHOICE_Step`:   range with step: default, min, max, step
- * `SPA_CHOICE_Enum`:   enum: default, alternative,...
- * `SPA_CHOICE_Flags`:  bitmask of flags
+- `SPA_CHOICE_None`: No choice, first value is current.
+- `SPA_CHOICE_Range`: Range: default, min, max.
+- `SPA_CHOICE_Step`: Range with step: default, min, max, step.
+- `SPA_CHOICE_Enum`: Enum: default, alternative,...
+- `SPA_CHOICE_Flags`: Bitmask of flags.
 
-Let's illustrate this with a Props object that specifies a range of
+Let's illustrate this with a props object that specifies a range of
 possible values for the frequency:
 
 \code{.c}
@@ -195,8 +197,8 @@
 pod = spa_pod_builder_pop(&b, &f);
 \endcode
 
-As you can see, first push the choice as a Range, then the values. A Range
-choice expects at least 3 values, the default value, minimum and maximum
+As you can see, first push the choice as a range, then the values. A range
+choice expects at least three values, the default value, minimum and maximum
 values. There is a shortcut for this as well using varargs:
 
 \code{.c}
@@ -205,7 +207,7 @@
 	SPA_PROP_frequency, SPA_POD_CHOICE_RANGE_Float(440.0f, 110.0f, 880.0f));
 \endcode
 
-## Choice examples
+## Choice Examples
 
 This is a description of a possible `SPA_TYPE_OBJECT_Format` as used when
 enumerating allowed formats (`SPA_PARAM_EnumFormat`) in SPA objects:
@@ -253,16 +255,17 @@
 	SPA_FORMAT_AUDIO_channels, SPA_POD_Int(2));
 \endcode
 
-# Parsing a POD
 
-Parsing a POD usually consists of
+# Parsing A POD
 
- * validating if raw bytes + size can contain a valid pod
- * inspecting the type of a pod
- * looping over the items in an object or struct
- * getting data out of PODs.
+Parsing a POD usually consists of:
 
-## Validating bytes
+- Validating if raw bytes + size can contain a valid POD.
+- Inspecting the type of a POD.
+- Looping over the items in an object or struct.
+- Getting data out of POD's.
+
+## Validating Bytes
 
 Use `spa_pod_from_data()` to check if maxsize of bytes in data contain
 a POD at the size bytes starting at offset. This function checks that
@@ -273,7 +276,7 @@
 pod = spa_pod_from_data(data, maxsize, offset, size);
 \endcode
 
-## Checking the type of POD
+## Checking The Type Of POD
 
 Use one of `spa_pod_is_bool()`, `spa_pod_is_int()`, etc to check
 for the type of the pod. For simple (non-container) types,
@@ -283,9 +286,9 @@
 `spa_pod_is_object_type()` can be used to check if the POD contains
 an object of the expected type.
 
-## Struct fields
+## Struct Fields
 
-To iterate over the fields of a Struct use:
+To iterate over the fields of a struct use:
 
 \code{.c}
 struct spa_pod *pod, *obj;
@@ -294,7 +297,7 @@
 }
 \endcode
 
-For parsing Structs it is usually much easier to use the parser
+For parsing structs it is usually much easier to use the parser
 below.
 
 ## Object Properties
@@ -363,7 +366,7 @@
 spa_pod_parser_pop(&p, &f);
 \endcode
 
-## Parser with variable arguments
+## Parser With Variable Arguments
 
 In most cases, parsing objects is easier with the variable argument
 functions. The parse function look like the mirror image of the builder
@@ -408,15 +411,15 @@
 	SPA_FORMAT_AUDIO_channels, SPA_POD_OPT_Int(&channels));
 \endcode
 
-It is not possible to parse a Sequence or Array with the parser.
+It is not possible to parse a sequence or array with the parser.
 Use the iterator for this.
 
-## Choice values
+## Choice Values
 
-The parser will handle Choice values as long as they are of type
-None. It will then parse the single value from the choice. When
+The parser will handle choice values as long as they are of type
+`none`. It will then parse the single value from the choice. When
 dealing with other choice values, it's possible to parse the
-property values into a `struct spa_pod` and then inspect the Choice
+property values into a `struct spa_pod` and then inspect the choice
 manually, if needed.
 
 Here is an example of parsing the format values as a POD:
@@ -432,9 +435,9 @@
 \endcode
 
 `spa_pod_get_values()` is a useful function. It returns a
-`struct spa_pod*` with and array of values. For normal PODs
-and Choice None values, it simply returns the POD and 1 value.
-For other Choice values it returns the Choice type and an array
+`struct spa_pod*` with and array of values. For normal POD's
+and choice none values, it simply returns the POD and one value.
+For other choice values it returns the choice type and an array
 of values:
 
 \code{.c}
@@ -464,15 +467,16 @@
 }
 \endcode
 
+
 # Filter
 
-Given 2 pod objects of the same type (Object, Struct, ..) one can
-run a filter and generate a new pod that only contains values that
-are compatible with both input pods.
+Given two POD objects of the same type (object, struct, ..) one can
+run a filter and generate a new POD that only contains values that
+are compatible with both input POD's.
 
 This is, for example, used to find a compatible format between two ports.
 
-As an example we can run a filter on two simple PODs:
+As an example we can run a filter on two simple POD's:
 
 \code{.c}
 pod = spa_pod_builder_add_object(&b,
@@ -511,7 +515,7 @@
 	SPA_FORMAT_AUDIO_format,   SPA_AUDIO_FORMAT_S16);
 \endcode
 
-# POD layout
+# POD Layout
 
 Each POD has a 32 bits size field, followed by a 32 bits type field. The size
 field specifies the size following the type field.

pipewire-0.3.51.tar.gz/doc/tutorial.dox -> pipewire-0.3.52.tar.gz/doc/tutorial.dox Changed

pipewire-0.3.51.tar.gz/doc/tutorial1.dox -> pipewire-0.3.52.tar.gz/doc/tutorial1.dox Changed

pipewire-0.3.51.tar.gz/doc/tutorial2.dox -> pipewire-0.3.52.tar.gz/doc/tutorial2.dox Changed

pipewire-0.3.51.tar.gz/doc/tutorial3.dox -> pipewire-0.3.52.tar.gz/doc/tutorial3.dox Changed

pipewire-0.3.51.tar.gz/doc/tutorial4.dox -> pipewire-0.3.52.tar.gz/doc/tutorial4.dox Changed

@@ -1,4 +1,4 @@
-/** \page page_tutorial4 Tutorial - Part 4: Playing a tone
+/** \page page_tutorial4 Tutorial - Part 4: Playing A Tone
 
 \ref page_tutorial3 | \ref page_tutorial "Index" | \ref page_tutorial5
 
@@ -57,13 +57,12 @@
 
 In the properties we need to give as much information about the stream as we
 can so that the session manager can make good decisions about how and where
-to route this stream. There are 3 important properties to configure:
+to route this stream. There are three important properties to configure:
 
-* `PW_KEY_MEDIA_TYPE`      The media type, like Audio, Video, Midi
-* `pw_KEY_MEDIA_CATEGORY`  The category, like Playback, Capture, Duplex, Monitor
-* `PW_KEY_MEDIA_ROLE`      The media role, like Movie, Music, Camera, Screen,
-					Communication, Game, Notification, DSP,
-					Production, Accessibility, Test
+- `PW_KEY_MEDIA_TYPE`: The media type; like Audio, Video, MIDI.
+- `PW_KEY_MEDIA_CATEGORY`: The category; like Playback, Capture, Duplex, Monitor.
+- `PW_KEY_MEDIA_ROLE`: The media role; like Movie, Music, Camera, Screen,
+  Communication, Game, Notification, DSP, Production, Accessibility, Test.
 
 The properties are owned by the stream and freed when the stream is destroyed
 later.
@@ -122,15 +121,14 @@
 To connect we specify that we have a `PW_DIRECTION_OUTPUT` stream. `PW_ID_ANY`
 means that we are ok with connecting to any consumer. Next we set some flags:
 
-* `PW_STREAM_FLAG_AUTOCONNECT`  automatically connect this stream. This instructs
-                                the session manager to link us to some consumer.
-* `PW_STREAM_FLAG_MAP_BUFFERS`	mmap the buffers for us so we can access the
-                                memory. If you don't set these flags you have
-				either work with the fd or mmap yourself.
-* `PW_STREAM_FLAG_RT_PROCESS` 	Run the process function in the realtime thread.
-		                Only use this if the process function only
-				uses functions that are realtime safe, this means
-				no allocation or file access or any locking.
+- `PW_STREAM_FLAG_AUTOCONNECT`: Automatically connect this stream. This instructs
+  the session manager to link us to some consumer.
+- `PW_STREAM_FLAG_MAP_BUFFERS`:	mmap the buffers for us so we can access the
+  memory. If you don't set these flags you have either work with the fd or mmap 
+  yourself.
+- `PW_STREAM_FLAG_RT_PROCESS`: Run the process function in the realtime thread.
+  Only use this if the process function only uses functions that are realtime 
+  safe, this means no allocation or file access or any locking.
 
 And last we pass the extra parameters for our stream. Here we only have the
 allowed formats (`SPA_PARAM_EnumFormat`).
@@ -140,11 +138,11 @@
 
 The main program flow of the process function is:
 
-* `pw_stream_dequeue_buffer()` to obtain a buffer to write into.
-* Get pointers in buffer memory to write to
-* write data into buffer
-* adjust buffer with number of written bytes, offset, stride,
-* `pw_stream_queue_buffer()` to queue the buffer for playback.
+- `pw_stream_dequeue_buffer()` to obtain a buffer to write into.
+- Get pointers in buffer memory to write to.
+- Write data into buffer.
+- Adjust buffer with number of written bytes, offset, stride.
+- `pw_stream_queue_buffer()` to queue the buffer for playback.
 
 \snippet tutorial4.c on_process

pipewire-0.3.51.tar.gz/doc/tutorial5.dox -> pipewire-0.3.52.tar.gz/doc/tutorial5.dox Changed

pipewire-0.3.51.tar.gz/doc/tutorial6.dox -> pipewire-0.3.52.tar.gz/doc/tutorial6.dox Changed

pipewire-0.3.51.tar.gz/man/pw-cat.1.rst.in -> pipewire-0.3.52.tar.gz/man/pw-cat.1.rst.in Changed

@@ -11,11 +11,12 @@
 SYNOPSIS
 ========
 
-| **pw-cat** *options* *FILE*
-| **pw-play** *options* *FILE*
-| **pw-record** *options* *FILE*
-| **pw-midiplay** *options* *FILE*
-| **pw-midirecord** *options* *FILE*
+| **pw-cat** *options* *FILE* \| -
+| **pw-play** *options* *FILE* \| -
+| **pw-record** *options* *FILE* \| -
+| **pw-midiplay** *options* *FILE* \| -
+| **pw-midirecord** *options* *FILE* \| -
+| **pw-dsdplay** *options* *FILE* \| -
 
 DESCRIPTION
 ===========
@@ -23,7 +24,14 @@
 **pw-cat** is a simple tool for playing back or
 capturing raw or encoded media files on a PipeWire
 server. It understands all audio file formats supported by
-``libsndfile``.
+``libsndfile`` for PCM capture and playback.
+
+It understands standard MIDI files for playback and recording,
+
+DSD playback is supported with the DSF file format.
+
+When the *FILE* is - input and output will be from STDIN and
+STDOUT respectively.
 
 OPTIONS
 =======
@@ -53,6 +61,10 @@
   MIDI mode. *FILE* is a MIDI file. If the tool is called under the name
   **pw-midiplay** or **pw-midirecord** this is the default.
 
+-d | --dsd
+  DSD mode. *FILE* is a DSF file. If the tool is called under the name
+  **pw-dsdplay** this is the default.
+
 --media-type=VALUE
   Set the media type property (default Audio/Midi depending on mode).
   The media type is used by the session manager to select a suitable target
@@ -97,6 +109,9 @@
   If no units are given, the latency value is samples with the samplerate
   of the file.
 
+-P | --properties=VALUE
+  Set extra stream properties as a JSON object.
+
 -q | --quality=VALUE
   Resampler quality. When the samplerate of the source or
   destination file does not match the samplerate of the server, the
@@ -129,11 +144,13 @@
 
 --format=VALUE
   The sample format to use. One of:
-  **s8**, **s16** (default), **s24**, **s32**,
+  **u8**, **s8**, **s16** (default), **s24**, **s32**,
   **f32**, **f64**.
 
 --volume=VALUE
   The stream volume, default 1.000.
+  Depending on the locale you have configured, "," or "." may be
+  used as a decimal seperator. Check with **locale** command.
 
 AUTHORS
 =======

pipewire-0.3.51.tar.gz/meson.build -> pipewire-0.3.52.tar.gz/meson.build Changed

pipewire-0.3.51.tar.gz/meson_options.txt -> pipewire-0.3.52.tar.gz/meson_options.txt Changed

pipewire-0.3.51.tar.gz/pipewire-alsa/alsa-plugins/pcm_pipewire.c -> pipewire-0.3.52.tar.gz/pipewire-alsa/alsa-plugins/pcm_pipewire.c Changed

@@ -721,6 +721,35 @@
 	return 0;
 }
 
+static int snd_pcm_pipewire_sw_params(snd_pcm_ioplug_t * io,
+				snd_pcm_sw_params_t * sw_params)
+{
+	snd_pcm_pipewire_t *pw = io->private_data;
+
+	if (pw->stream) {
+		snd_pcm_uframes_t min_avail;
+		snd_pcm_sw_params_get_avail_min( sw_params, &min_avail);
+		snd_pcm_sw_params_get_boundary(sw_params, &pw->boundary);
+		if (min_avail != pw->min_avail) {
+			char latency64;
+			struct spa_dict_item item1;
+			uint32_t min_period = (MIN_PERIOD * io->rate / 48000);
+
+			pw->min_avail = SPA_MAX(min_avail, min_period);
+
+			spa_scnprintf(latency, sizeof(latency), "%lu/%u", pw->min_avail, io->rate);
+			item0 = SPA_DICT_ITEM_INIT(PW_KEY_NODE_LATENCY, latency);
+
+			pw_log_debug("%p: sw_params update props %p %ld", pw, pw->stream, pw->min_avail);
+			pw_stream_update_properties(pw->stream, &SPA_DICT_INIT(item, 1));
+		}
+	} else {
+		pw_log_debug("%p: sw_params pre-prepare noop", pw);
+	}
+
+	return 0;
+}
+
 struct chmap_info {
 	enum snd_pcm_chmap_position pos;
 	enum spa_audio_channel channel;
@@ -855,6 +884,7 @@
 	.poll_descriptors = snd_pcm_pipewire_poll_descriptors,
 	.poll_revents = snd_pcm_pipewire_poll_revents,
 	.hw_params = snd_pcm_pipewire_hw_params,
+	.sw_params = snd_pcm_pipewire_sw_params,
 	.set_chmap = snd_pcm_pipewire_set_chmap,
 	.get_chmap = snd_pcm_pipewire_get_chmap,
 	.query_chmaps = snd_pcm_pipewire_query_chmaps,

pipewire-0.3.51.tar.gz/pipewire-jack/src/metadata.c -> pipewire-0.3.52.tar.gz/pipewire-jack/src/metadata.c Changed

pipewire-0.3.51.tar.gz/pipewire-jack/src/pipewire-jack.c -> pipewire-0.3.52.tar.gz/pipewire-jack/src/pipewire-jack.c Changed

@@ -3205,6 +3205,30 @@
 	varargs_parse(client, options, ap);
 	va_end(ap);
 
+	snprintf(client->name, sizeof(client->name), "pw-%s", client_name);
+
+	pthread_mutex_init(&client->context.lock, NULL);
+	spa_list_init(&client->context.objects);
+
+	client->node_id = SPA_ID_INVALID;
+
+	client->buffer_frames = (uint32_t)-1;
+	client->sample_rate = (uint32_t)-1;
+	client->latency = SPA_FRACTION(-1, -1);
+
+	spa_list_init(&client->mix);
+	spa_list_init(&client->free_mix);
+
+	spa_list_init(&client->free_ports);
+	pw_map_init(&client->portsSPA_DIRECTION_INPUT, 32, 32);
+	pw_map_init(&client->portsSPA_DIRECTION_OUTPUT, 32, 32);
+
+	spa_list_init(&client->links);
+	client->driver_id = SPA_ID_INVALID;
+
+	spa_list_init(&client->rt.target_links);
+	pthread_mutex_init(&client->rt_lock, NULL);
+
 	if (client->server_name != NULL &&
 	    spa_streq(client->server_name, "default"))
 		client->server_name = NULL;
@@ -3219,8 +3243,6 @@
 	if (client->props == NULL)
 		goto no_props;
 
-	client->node_id = SPA_ID_INVALID;
-	snprintf(client->name, sizeof(client->name), "pw-%s", client_name);
 	client->context.loop = pw_thread_loop_new(client->name, NULL);
 	client->context.l = pw_thread_loop_get_loop(client->context.loop);
 	client->context.context = pw_context_new(
@@ -3239,30 +3261,6 @@
 	pw_context_conf_section_match_rules(client->context.context, "jack.rules",
 			&client->props->dict, execute_match, client);
 
-	client->show_monitor = pw_properties_get_bool(client->props, "jack.show-monitor", true);
-	client->merge_monitor = pw_properties_get_bool(client->props, "jack.merge-monitor", false);
-	client->short_name = pw_properties_get_bool(client->props, "jack.short-name", false);
-	client->filter_name = pw_properties_get_bool(client->props, "jack.filter-name", false);
-	client->locked_process = pw_properties_get_bool(client->props, "jack.locked-process", true);
-	client->default_as_system = pw_properties_get_bool(client->props, "jack.default-as-system", false);
-
-	client->self_connect_mode = SELF_CONNECT_ALLOW;
-	if ((str = pw_properties_get(client->props, "jack.self-connect-mode")) != NULL) {
-		if (spa_streq(str, "fail-external"))
-			client->self_connect_mode = SELF_CONNECT_FAIL_EXT;
-		else if (spa_streq(str, "ignore-external"))
-			client->self_connect_mode = SELF_CONNECT_IGNORE_EXT;
-		else if (spa_streq(str, "fail-all"))
-			client->self_connect_mode = SELF_CONNECT_FAIL_ALL;
-		else if (spa_streq(str, "ignore-all"))
-			client->self_connect_mode = SELF_CONNECT_IGNORE_ALL;
-	}
-	client->rt_max = pw_properties_get_int32(client->props, "rt.prio", DEFAULT_RT_MAX);
-
-	pthread_mutex_init(&client->context.lock, NULL);
-	pthread_mutex_init(&client->rt_lock, NULL);
-	spa_list_init(&client->context.objects);
-
 	support = pw_context_get_support(client->context.context, &n_support);
 
 	mix2 = mix2_c;
@@ -3292,20 +3290,6 @@
 			SPA_TYPE_INTERFACE_ThreadUtils,
 			&client->context.thread_utils);
 
-	spa_list_init(&client->links);
-	spa_list_init(&client->rt.target_links);
-
-	client->buffer_frames = (uint32_t)-1;
-	client->sample_rate = (uint32_t)-1;
-	client->latency = SPA_FRACTION(-1, -1);
-
-        spa_list_init(&client->mix);
-        spa_list_init(&client->free_mix);
-
-	pw_map_init(&client->portsSPA_DIRECTION_INPUT, 32, 32);
-	pw_map_init(&client->portsSPA_DIRECTION_OUTPUT, 32, 32);
-	spa_list_init(&client->free_ports);
-
 	pw_thread_loop_start(client->context.loop);
 
 	pw_thread_loop_lock(client->context.loop);
@@ -3393,6 +3377,26 @@
 			0, NULL, &client->info);
 	client->info.change_mask = 0;
 
+	client->show_monitor = pw_properties_get_bool(client->props, "jack.show-monitor", true);
+	client->merge_monitor = pw_properties_get_bool(client->props, "jack.merge-monitor", false);
+	client->short_name = pw_properties_get_bool(client->props, "jack.short-name", false);
+	client->filter_name = pw_properties_get_bool(client->props, "jack.filter-name", false);
+	client->locked_process = pw_properties_get_bool(client->props, "jack.locked-process", true);
+	client->default_as_system = pw_properties_get_bool(client->props, "jack.default-as-system", false);
+
+	client->self_connect_mode = SELF_CONNECT_ALLOW;
+	if ((str = pw_properties_get(client->props, "jack.self-connect-mode")) != NULL) {
+		if (spa_streq(str, "fail-external"))
+			client->self_connect_mode = SELF_CONNECT_FAIL_EXT;
+		else if (spa_streq(str, "ignore-external"))
+			client->self_connect_mode = SELF_CONNECT_IGNORE_EXT;
+		else if (spa_streq(str, "fail-all"))
+			client->self_connect_mode = SELF_CONNECT_FAIL_ALL;
+		else if (spa_streq(str, "ignore-all"))
+			client->self_connect_mode = SELF_CONNECT_IGNORE_ALL;
+	}
+	client->rt_max = pw_properties_get_int32(client->props, "rt.prio", DEFAULT_RT_MAX);
+
 	if (status)
 		*status = 0;
 
@@ -3432,7 +3436,7 @@
 exit_unlock:
 	pw_thread_loop_unlock(client->context.loop);
 exit:
-	free(client);
+	jack_client_close((jack_client_t *) client);
 	return NULL;
 disabled:
 	if (status)
@@ -3467,20 +3471,29 @@
 
 	res = jack_deactivate(client);
 
-	pw_thread_loop_stop(c->context.loop);
+	if (c->context.loop)
+		pw_thread_loop_stop(c->context.loop);
 
 	if (c->registry) {
 		spa_hook_remove(&c->registry_listener);
 		pw_proxy_destroy((struct pw_proxy*)c->registry);
 	}
 	if (c->metadata && c->metadata->proxy) {
+		spa_hook_remove(&c->metadata->listener);
+		spa_hook_remove(&c->metadata->proxy_listener);
 		pw_proxy_destroy((struct pw_proxy*)c->metadata->proxy);
 	}
-	spa_hook_remove(&c->core_listener);
-	pw_core_disconnect(c->core);
-	pw_context_destroy(c->context.context);
 
-	pw_thread_loop_destroy(c->context.loop);
+	if (c->core) {
+		spa_hook_remove(&c->core_listener);
+		pw_core_disconnect(c->core);
+	}
+
+	if (c->context.context)
+		pw_context_destroy(c->context.context);
+
+	if (c->context.loop)
+		pw_thread_loop_destroy(c->context.loop);
 
 	pw_log_debug("%p: free", client);
 
@@ -5768,17 +5781,21 @@
 int jack_set_sync_timeout (jack_client_t *client,
 			   jack_time_t timeout)
 {
+	int res = 0;
 	struct client *c = (struct client *) client;
 	struct pw_node_activation *a;
 
 	spa_return_val_if_fail(c != NULL, -EINVAL);
 
-	if ((a = c->activation) == NULL)
-		return -EIO;
+	pw_thread_loop_lock(c->context.loop);
 
-	ATOMIC_STORE(a->sync_timeout, timeout);
+	if ((a = c->activation) == NULL)
+		res = -EIO;
+	else
+		a->sync_timeout = timeout;
+	pw_thread_loop_unlock(c->context.loop);
 
-	return 0;
+	return res;
 }
 
 SPA_EXPORT

pipewire-0.3.51.tar.gz/po/pl.po -> pipewire-0.3.52.tar.gz/po/pl.po Changed

@@ -8,8 +8,8 @@
 "Project-Id-Version: pipewire\n"
 "Report-Msgid-Bugs-To: https://gitlab.freedesktop.org/pipewire/pipewire/-/"
 "issues\n"
-"POT-Creation-Date: 2022-02-13 15:33+0000\n"
-"PO-Revision-Date: 2022-03-13 12:05+0100\n"
+"POT-Creation-Date: 2022-05-20 15:26+0000\n"
+"PO-Revision-Date: 2022-05-21 12:49+0200\n"
 "Last-Translator: Piotr Drąg <piotrdrag@gmail.com>\n"
 "Language-Team: Polish <community-poland@mozilla.org>\n"
 "Language: pl\n"
@@ -19,7 +19,7 @@
 "Plural-Forms: nplurals=3; plural=n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 "
 "|| n%100>=20) ? 1 : 2;\n"
 
-#: src/daemon/pipewire.c:45
+#: src/daemon/pipewire.c:46
 #, c-format
 msgid ""
 "%s options\n"
@@ -41,8 +41,8 @@
 msgid "Start the PipeWire Media System"
 msgstr "Uruchomienie systemu multimediów PipeWire"
 
-#: src/modules/module-protocol-pulse/modules/module-tunnel-sink.c:188
-#: src/modules/module-protocol-pulse/modules/module-tunnel-source.c:188
+#: src/modules/module-protocol-pulse/modules/module-tunnel-sink.c:183
+#: src/modules/module-protocol-pulse/modules/module-tunnel-source.c:183
 #, c-format
 msgid "Tunnel to %s/%s"
 msgstr "Tunel do %s/%s"
@@ -51,7 +51,7 @@
 msgid "Dummy Output"
 msgstr "Głuche wyjście"
 
-#: src/modules/module-pulse-tunnel.c:536
+#: src/modules/module-pulse-tunnel.c:639
 #, c-format
 msgid "Tunnel for %s@%s"
 msgstr "Tunel dla %s@%s"
@@ -70,22 +70,22 @@
 msgid "%s on %s"
 msgstr "%s na %s"
 
-#: src/tools/pw-cat.c:1075
+#: src/tools/pw-cat.c:872
 #, c-format
 msgid ""
-"%s options <file>\n"
+"%s options <file>|-\n"
 "  -h, --help                            Show this help\n"
 "      --version                         Show version\n"
 "  -v, --verbose                         Enable verbose operations\n"
 "\n"
 msgstr ""
-"%s opcje <plik>\n"
+"%s opcje <plik>|-\n"
 "  -h, --help                            Wyświetla tę pomoc\n"
 "      --version                         Wyświetla wersję\n"
 "  -v, --verbose                         Wyświetla więcej komunikatów\n"
 "\n"
 
-#: src/tools/pw-cat.c:1082
+#: src/tools/pw-cat.c:879
 #, c-format
 msgid ""
 "  -R, --remote                          Remote daemon name\n"
@@ -99,7 +99,7 @@
 "                                          or direct samples (256)\n"
 "                                          the rate is the one of the source "
 "file\n"
-"      --list-targets                    List available targets for --target\n"
+"  -P  --properties                      Set node properties\n"
 "\n"
 msgstr ""
 "  -R, --remote                          Nazwa zdalnej usługi\n"
@@ -119,11 +119,10 @@
 "                                          lub bezpośrednie próbki (256)\n"
 "                                          częstotliwość jest z pliku "
 "źródłowego\n"
-"      --list-targets                    Wyświetla listę dostępnych elementów "
-"docelowych dla --target\n"
+"  -P  --properties                      Ustawia właściwości węzła\n"
 "\n"
 
-#: src/tools/pw-cat.c:1100
+#: src/tools/pw-cat.c:897
 #, c-format
 msgid ""
 "      --rate                            Sample rate (req. for rec) (default "
@@ -159,7 +158,7 @@
 "(domyślnie %d)\n"
 "\n"
 
-#: src/tools/pw-cat.c:1117
+#: src/tools/pw-cat.c:914
 msgid ""
 "  -p, --playback                        Playback mode\n"
 "  -r, --record                          Recording mode\n"
@@ -173,7 +172,7 @@
 "  -d, --dsd                             Tryb DSD\n"
 "\n"
 
-#: src/tools/pw-cli.c:3050
+#: src/tools/pw-cli.c:3139
 #, c-format
 msgid ""
 "%s options command\n"
@@ -196,7 +195,7 @@
 msgstr "Dźwięk w zastosowaniach profesjonalnych"
 
 #: spa/plugins/alsa/acp/acp.c:444 spa/plugins/alsa/acp/alsa-mixer.c:4648
-#: spa/plugins/bluez5/bluez5-device.c:1159
+#: spa/plugins/bluez5/bluez5-device.c:1161
 msgid "Off"
 msgstr "Wyłączone"
 
@@ -223,7 +222,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2657
 #: spa/plugins/alsa/acp/alsa-mixer.c:2741
-#: spa/plugins/bluez5/bluez5-device.c:1328
+#: spa/plugins/bluez5/bluez5-device.c:1330
 msgid "Microphone"
 msgstr "Mikrofon"
 
@@ -289,7 +288,7 @@
 msgstr "Brak podbicia basów"
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2672
-#: spa/plugins/bluez5/bluez5-device.c:1333
+#: spa/plugins/bluez5/bluez5-device.c:1335
 msgid "Speaker"
 msgstr "Głośnik"
 
@@ -404,7 +403,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:4484
 #: spa/plugins/alsa/acp/alsa-mixer.c:4642
-#: spa/plugins/bluez5/bluez5-device.c:1318
+#: spa/plugins/bluez5/bluez5-device.c:1320
 msgid "Headset"
 msgstr "Słuchawki z mikrofonem"
 
@@ -518,12 +517,12 @@
 msgid "Mono Chat + 7.1 Surround"
 msgstr "Rozmowa mono + przestrzenne 7.1"
 
-#: spa/plugins/alsa/acp/alsa-mixer.c:4750
+#: spa/plugins/alsa/acp/alsa-mixer.c:4754
 #, c-format
 msgid "%s Output"
 msgstr "Wyjście %s"
 
-#: spa/plugins/alsa/acp/alsa-mixer.c:4757
+#: spa/plugins/alsa/acp/alsa-mixer.c:4761
 #, c-format
 msgid "%s Input"
 msgstr "Wejście %s"
@@ -628,61 +627,61 @@
 msgid "Modem"
 msgstr "Modem"
 
-#: spa/plugins/bluez5/bluez5-device.c:1170
+#: spa/plugins/bluez5/bluez5-device.c:1172
 msgid "Audio Gateway (A2DP Source & HSP/HFP AG)"
 msgstr "Bramka dźwięku (źródło A2DP i AG HSP/HFP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1195
+#: spa/plugins/bluez5/bluez5-device.c:1197
 #, c-format
 msgid "High Fidelity Playback (A2DP Sink, codec %s)"
 msgstr "Odtwarzanie o wysokiej dokładności (odpływ A2DP, kodek %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1198
+#: spa/plugins/bluez5/bluez5-device.c:1200
 #, c-format
 msgid "High Fidelity Duplex (A2DP Source/Sink, codec %s)"
 msgstr "Dupleks o wysokiej dokładności (źródło/odpływ A2DP, kodek %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1206
+#: spa/plugins/bluez5/bluez5-device.c:1208
 msgid "High Fidelity Playback (A2DP Sink)"
 msgstr "Odtwarzanie o wysokiej dokładności (odpływ A2DP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1208
+#: spa/plugins/bluez5/bluez5-device.c:1210
 msgid "High Fidelity Duplex (A2DP Source/Sink)"
 msgstr "Dupleks o wysokiej dokładności (źródło/odpływ A2DP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1236
+#: spa/plugins/bluez5/bluez5-device.c:1238
 #, c-format
 msgid "Headset Head Unit (HSP/HFP, codec %s)"
 msgstr "Jednostka główna słuchawek z mikrofonem (HSP/HFP, kodek %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1241
+#: spa/plugins/bluez5/bluez5-device.c:1243
 msgid "Headset Head Unit (HSP/HFP)"
 msgstr "Jednostka główna słuchawek z mikrofonem (HSP/HFP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1323
+#: spa/plugins/bluez5/bluez5-device.c:1325
 msgid "Handsfree"
 msgstr "Zestaw głośnomówiący"
 
-#: spa/plugins/bluez5/bluez5-device.c:1338
+#: spa/plugins/bluez5/bluez5-device.c:1340
 msgid "Headphone"
 msgstr "Słuchawki"
 
-#: spa/plugins/bluez5/bluez5-device.c:1343
+#: spa/plugins/bluez5/bluez5-device.c:1345
 msgid "Portable"
 msgstr "Przenośne"
 
-#: spa/plugins/bluez5/bluez5-device.c:1348
+#: spa/plugins/bluez5/bluez5-device.c:1350
 msgid "Car"
 msgstr "Samochód"
 
-#: spa/plugins/bluez5/bluez5-device.c:1353
+#: spa/plugins/bluez5/bluez5-device.c:1355
 msgid "HiFi"
 msgstr "HiFi"
 
-#: spa/plugins/bluez5/bluez5-device.c:1358
+#: spa/plugins/bluez5/bluez5-device.c:1360
 msgid "Phone"
 msgstr "Telefon"
 
-#: spa/plugins/bluez5/bluez5-device.c:1364
+#: spa/plugins/bluez5/bluez5-device.c:1366
 msgid "Bluetooth"
 msgstr "Bluetooth"

pipewire-0.3.51.tar.gz/po/sv.po -> pipewire-0.3.52.tar.gz/po/sv.po Changed

@@ -19,8 +19,8 @@
 "Project-Id-Version: pipewire\n"
 "Report-Msgid-Bugs-To: https://gitlab.freedesktop.org/pipewire/pipewire/-/"
 "issues\n"
-"POT-Creation-Date: 2022-04-13 15:28+0000\n"
-"PO-Revision-Date: 2022-04-15 22:03+0200\n"
+"POT-Creation-Date: 2022-05-20 15:26+0000\n"
+"PO-Revision-Date: 2022-05-23 11:01+0200\n"
 "Last-Translator: Anders Jonsson <anders.jonsson@norsjovallen.se>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
 "Language: sv\n"
@@ -38,7 +38,7 @@
 "      --version                         Show version\n"
 "  -c, --config                          Load config (Default %s)\n"
 msgstr ""
-"%s options\n"
+"%s flaggor\n"
 "  -h, --help                            Visa denna hjälp\n"
 "      --version                         Visa version\n"
 "  -c, --config                          Läs in konfig (Standard %s)\n"
@@ -61,41 +61,41 @@
 msgid "Dummy Output"
 msgstr "Attrapputgång"
 
-#: src/modules/module-pulse-tunnel.c:545
+#: src/modules/module-pulse-tunnel.c:639
 #, c-format
 msgid "Tunnel for %s@%s"
 msgstr "Tunnel för %s@%s"
 
-#: src/modules/module-zeroconf-discover.c:313
+#: src/modules/module-zeroconf-discover.c:332
 msgid "Unknown device"
 msgstr "Okänd enhet"
 
-#: src/modules/module-zeroconf-discover.c:325
+#: src/modules/module-zeroconf-discover.c:344
 #, c-format
 msgid "%s on %s@%s"
 msgstr "%s på %s@%s"
 
-#: src/modules/module-zeroconf-discover.c:329
+#: src/modules/module-zeroconf-discover.c:348
 #, c-format
 msgid "%s on %s"
 msgstr "%s på %s"
 
-#: src/tools/pw-cat.c:867
+#: src/tools/pw-cat.c:872
 #, c-format
 msgid ""
-"%s options <file>\n"
+"%s options <file>|-\n"
 "  -h, --help                            Show this help\n"
 "      --version                         Show version\n"
 "  -v, --verbose                         Enable verbose operations\n"
 "\n"
 msgstr ""
-"%s options <file>\n"
+"%s flaggor <fil>|-\n"
 "  -h, --help                            Visa denna hjälp\n"
 "      --version                         Visa version\n"
 "  -v, --verbose                         Aktivera utförliga operationer\n"
 "\n"
 
-#: src/tools/pw-cat.c:874
+#: src/tools/pw-cat.c:879
 #, c-format
 msgid ""
 "  -R, --remote                          Remote daemon name\n"
@@ -109,6 +109,7 @@
 "                                          or direct samples (256)\n"
 "                                          the rate is the one of the source "
 "file\n"
+"  -P  --properties                      Set node properties\n"
 "\n"
 msgstr ""
 "  -R, --remote                          Fjärrdemonnamn\n"
@@ -121,9 +122,10 @@
 "                                          Xenhet (enhet = s, ms, us, ns)\n"
 "                                          eller direkta samplar (256)\n"
 "                                          hastigheten är källfilens\n"
+"  -P  --properties                      Sätt nodegenskaper\n"
 "\n"
 
-#: src/tools/pw-cat.c:891
+#: src/tools/pw-cat.c:897
 #, c-format
 msgid ""
 "      --rate                            Sample rate (req. for rec) (default "
@@ -158,7 +160,7 @@
 "%d)\n"
 "\n"
 
-#: src/tools/pw-cat.c:908
+#: src/tools/pw-cat.c:914
 msgid ""
 "  -p, --playback                        Playback mode\n"
 "  -r, --record                          Recording mode\n"
@@ -172,7 +174,7 @@
 "  -d, --dsd                             DSD-läge\n"
 "\n"
 
-#: src/tools/pw-cli.c:3051
+#: src/tools/pw-cli.c:3139
 #, c-format
 msgid ""
 "%s options command\n"
@@ -194,7 +196,7 @@
 msgstr "Professionellt ljud"
 
 #: spa/plugins/alsa/acp/acp.c:444 spa/plugins/alsa/acp/alsa-mixer.c:4648
-#: spa/plugins/bluez5/bluez5-device.c:1159
+#: spa/plugins/bluez5/bluez5-device.c:1161
 msgid "Off"
 msgstr "Av"
 
@@ -221,7 +223,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2657
 #: spa/plugins/alsa/acp/alsa-mixer.c:2741
-#: spa/plugins/bluez5/bluez5-device.c:1328
+#: spa/plugins/bluez5/bluez5-device.c:1330
 msgid "Microphone"
 msgstr "Mikrofon"
 
@@ -287,7 +289,7 @@
 msgstr "Ingen basökning"
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2672
-#: spa/plugins/bluez5/bluez5-device.c:1333
+#: spa/plugins/bluez5/bluez5-device.c:1335
 msgid "Speaker"
 msgstr "Högtalare"
 
@@ -402,7 +404,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:4484
 #: spa/plugins/alsa/acp/alsa-mixer.c:4642
-#: spa/plugins/bluez5/bluez5-device.c:1318
+#: spa/plugins/bluez5/bluez5-device.c:1320
 msgid "Headset"
 msgstr "Headset"
 
@@ -620,61 +622,61 @@
 msgid "Modem"
 msgstr "Modem"
 
-#: spa/plugins/bluez5/bluez5-device.c:1170
+#: spa/plugins/bluez5/bluez5-device.c:1172
 msgid "Audio Gateway (A2DP Source & HSP/HFP AG)"
 msgstr "Audio gateway (A2DP-källa & HSP/HFP AG)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1195
+#: spa/plugins/bluez5/bluez5-device.c:1197
 #, c-format
 msgid "High Fidelity Playback (A2DP Sink, codec %s)"
 msgstr "High fidelity-uppspelning (A2DP-utgång, kodek %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1198
+#: spa/plugins/bluez5/bluez5-device.c:1200
 #, c-format
 msgid "High Fidelity Duplex (A2DP Source/Sink, codec %s)"
 msgstr "High fidelity duplex (A2DP-källa/utgång, kodek %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1206
+#: spa/plugins/bluez5/bluez5-device.c:1208
 msgid "High Fidelity Playback (A2DP Sink)"
 msgstr "High fidelity-uppspelning (A2DP-utgång)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1208
+#: spa/plugins/bluez5/bluez5-device.c:1210
 msgid "High Fidelity Duplex (A2DP Source/Sink)"
 msgstr "High fidelity duplex (A2DP-källa/utgång)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1236
+#: spa/plugins/bluez5/bluez5-device.c:1238
 #, c-format
 msgid "Headset Head Unit (HSP/HFP, codec %s)"
 msgstr "Headset-huvudenhet (HSP/HFP, kodek %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1241
+#: spa/plugins/bluez5/bluez5-device.c:1243
 msgid "Headset Head Unit (HSP/HFP)"
 msgstr "Headset-huvudenhet (HSP/HFP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1323
+#: spa/plugins/bluez5/bluez5-device.c:1325
 msgid "Handsfree"
 msgstr "Handsfree"
 
-#: spa/plugins/bluez5/bluez5-device.c:1338
+#: spa/plugins/bluez5/bluez5-device.c:1340
 msgid "Headphone"
 msgstr "Hörlurar"
 
-#: spa/plugins/bluez5/bluez5-device.c:1343
+#: spa/plugins/bluez5/bluez5-device.c:1345
 msgid "Portable"
 msgstr "Bärbar"
 
-#: spa/plugins/bluez5/bluez5-device.c:1348
+#: spa/plugins/bluez5/bluez5-device.c:1350
 msgid "Car"
 msgstr "Bil"
 
-#: spa/plugins/bluez5/bluez5-device.c:1353
+#: spa/plugins/bluez5/bluez5-device.c:1355
 msgid "HiFi"
 msgstr "HiFi"
 
-#: spa/plugins/bluez5/bluez5-device.c:1358
+#: spa/plugins/bluez5/bluez5-device.c:1360
 msgid "Phone"
 msgstr "Telefon"
 
-#: spa/plugins/bluez5/bluez5-device.c:1364
+#: spa/plugins/bluez5/bluez5-device.c:1366
 msgid "Bluetooth"
 msgstr "Bluetooth"

pipewire-0.3.51.tar.gz/po/tr.po -> pipewire-0.3.52.tar.gz/po/tr.po Changed

@@ -4,16 +4,16 @@
 # Necdet Yücel <necdetyucel@gmail.com>, 2014.
 # Kaan Özdinçer <kaanozdincer@gmail.com>, 2014.
 # Muhammet Kara <muhammetk@gmail.com>, 2015, 2016, 2017.
-# Oğuz Ersen <oguzersen@protonmail.com>, 2021.
+# Oğuz Ersen <oguz@ersen.moe>, 2021-2022.
 #
 msgid ""
 msgstr ""
 "Project-Id-Version: PipeWire master\n"
 "Report-Msgid-Bugs-To: https://gitlab.freedesktop.org/pipewire/pipewire/"
 "issues/new\n"
-"POT-Creation-Date: 2021-11-17 15:06+0100\n"
-"PO-Revision-Date: 2021-12-06 21:31+0300\n"
-"Last-Translator: Oğuz Ersen <oguzersen@protonmail.com>\n"
+"POT-Creation-Date: 2022-04-03 12:56+0200\n"
+"PO-Revision-Date: 2022-05-14 18:35+0300\n"
+"Last-Translator: Oğuz Ersen <oguz@ersen.moe>\n"
 "Language-Team: Turkish <tr>\n"
 "Language: tr\n"
 "MIME-Version: 1.0\n"
@@ -22,7 +22,7 @@
 "Plural-Forms: nplurals=1; plural=0;\n"
 "X-Generator: Weblate 4.4.2\n"
 
-#: src/daemon/pipewire.c:45
+#: src/daemon/pipewire.c:46
 #, c-format
 msgid ""
 "%s options\n"
@@ -35,32 +35,36 @@
 "      --version                         Sürümü göster\n"
 "  -c, --config                          Yapılandırmayı yükle (Öntanımlı %s)\n"
 
-#: src/modules/module-protocol-pulse/modules/module-tunnel-sink.c:185
-#: src/modules/module-protocol-pulse/modules/module-tunnel-source.c:185
+#: src/modules/module-protocol-pulse/modules/module-tunnel-sink.c:190
+#: src/modules/module-protocol-pulse/modules/module-tunnel-source.c:190
 #, c-format
 msgid "Tunnel to %s/%s"
 msgstr "%s/%s tüneli"
 
-#: src/modules/module-pulse-tunnel.c:536
+#: src/modules/module-fallback-sink.c:51
+msgid "Dummy Output"
+msgstr "Temsili Çıkış"
+
+#: src/modules/module-pulse-tunnel.c:545
 #, c-format
 msgid "Tunnel for %s@%s"
 msgstr "%s@%s için tünel"
 
-#: src/modules/module-zeroconf-discover.c:332
+#: src/modules/module-zeroconf-discover.c:313
 msgid "Unknown device"
 msgstr "Bilinmeyen aygıt"
 
-#: src/modules/module-zeroconf-discover.c:344
+#: src/modules/module-zeroconf-discover.c:325
 #, c-format
 msgid "%s on %s@%s"
 msgstr "%s, %s@%s"
 
-#: src/modules/module-zeroconf-discover.c:348
+#: src/modules/module-zeroconf-discover.c:329
 #, c-format
 msgid "%s on %s"
 msgstr "%s, %s"
 
-#: src/tools/pw-cat.c:1058
+#: src/tools/pw-cat.c:1087
 #, c-format
 msgid ""
 "%s options <file>\n"
@@ -75,7 +79,7 @@
 "  -v, --verbose                         Ayrıntılı işlemleri etkinleştir\n"
 "\n"
 
-#: src/tools/pw-cat.c:1065
+#: src/tools/pw-cat.c:1094
 #, c-format
 msgid ""
 "  -R, --remote                          Remote daemon name\n"
@@ -109,7 +113,7 @@
 "hedefleri listele\n"
 "\n"
 
-#: src/tools/pw-cat.c:1083
+#: src/tools/pw-cat.c:1112
 #, c-format
 msgid ""
 "      --rate                            Sample rate (req. for rec) (default "
@@ -145,7 +149,7 @@
 "15) (öntanımlı %d)\n"
 "\n"
 
-#: src/tools/pw-cat.c:1100
+#: src/tools/pw-cat.c:1129
 msgid ""
 "  -p, --playback                        Playback mode\n"
 "  -r, --record                          Recording mode\n"
@@ -159,7 +163,7 @@
 "  -d, --dsd                             DSD modu\n"
 "\n"
 
-#: src/tools/pw-cli.c:3018
+#: src/tools/pw-cli.c:3051
 #, c-format
 msgid ""
 "%s options command\n"
@@ -182,7 +186,7 @@
 msgstr "Profesyonel Ses"
 
 #: spa/plugins/alsa/acp/acp.c:444 spa/plugins/alsa/acp/alsa-mixer.c:4648
-#: spa/plugins/bluez5/bluez5-device.c:1145
+#: spa/plugins/bluez5/bluez5-device.c:1159
 msgid "Off"
 msgstr "Kapalı"
 
@@ -209,7 +213,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2657
 #: spa/plugins/alsa/acp/alsa-mixer.c:2741
-#: spa/plugins/bluez5/bluez5-device.c:1302
+#: spa/plugins/bluez5/bluez5-device.c:1328
 msgid "Microphone"
 msgstr "Mikrofon"
 
@@ -275,7 +279,7 @@
 msgstr "Bas Artırma Yok"
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2672
-#: spa/plugins/bluez5/bluez5-device.c:1307
+#: spa/plugins/bluez5/bluez5-device.c:1333
 msgid "Speaker"
 msgstr "Hoparlör"
 
@@ -390,7 +394,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:4484
 #: spa/plugins/alsa/acp/alsa-mixer.c:4642
-#: spa/plugins/bluez5/bluez5-device.c:1292
+#: spa/plugins/bluez5/bluez5-device.c:1318
 msgid "Headset"
 msgstr "Kulaklık"
 
@@ -504,12 +508,12 @@
 msgid "Mono Chat + 7.1 Surround"
 msgstr "Tek Kanallı Sohbet + 7.1 Çevresel Ses"
 
-#: spa/plugins/alsa/acp/alsa-mixer.c:4750
+#: spa/plugins/alsa/acp/alsa-mixer.c:4754
 #, c-format
 msgid "%s Output"
 msgstr "%s Çıkışı"
 
-#: spa/plugins/alsa/acp/alsa-mixer.c:4757
+#: spa/plugins/alsa/acp/alsa-mixer.c:4761
 #, c-format
 msgid "%s Input"
 msgstr "%s Girişi"
@@ -534,13 +538,13 @@
 #: spa/plugins/alsa/acp/alsa-util.c:1239
 #, c-format
 msgid ""
-"snd_pcm_delay() returned a value that is exceptionally large: %li byte (%s"
-"%lu ms).\n"
+"snd_pcm_delay() returned a value that is exceptionally large: %li byte "
+"(%s%lu ms).\n"
 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue "
 "to the ALSA developers."
 msgid_plural ""
-"snd_pcm_delay() returned a value that is exceptionally large: %li bytes (%s"
-"%lu ms).\n"
+"snd_pcm_delay() returned a value that is exceptionally large: %li bytes "
+"(%s%lu ms).\n"
 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue "
 "to the ALSA developers."
 msgstr0 ""
@@ -591,62 +595,62 @@
 msgid "Modem"
 msgstr "Modem"
 
-#: spa/plugins/bluez5/bluez5-device.c:1155
+#: spa/plugins/bluez5/bluez5-device.c:1170
 msgid "Audio Gateway (A2DP Source & HSP/HFP AG)"
 msgstr "Ses Geçidi (A2DP Kaynak & HSP/HFP AG)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1178
+#: spa/plugins/bluez5/bluez5-device.c:1195
 #, c-format
 msgid "High Fidelity Playback (A2DP Sink, codec %s)"
 msgstr "Yüksek Kaliteli Çalma (A2DP Alıcı, çözücü %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1181
+#: spa/plugins/bluez5/bluez5-device.c:1198
 #, c-format
 msgid "High Fidelity Duplex (A2DP Source/Sink, codec %s)"
 msgstr "Yüksek Kaliteli İkili (A2DP Kaynak/Alıcı, çözücü %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1188
+#: spa/plugins/bluez5/bluez5-device.c:1206
 msgid "High Fidelity Playback (A2DP Sink)"
 msgstr "Yüksek Kaliteli Çalma (A2DP Alıcı)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1190
+#: spa/plugins/bluez5/bluez5-device.c:1208
 msgid "High Fidelity Duplex (A2DP Source/Sink)"
 msgstr "Yüksek Kaliteli İkili (A2DP Kaynak/Alıcı)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1217
+#: spa/plugins/bluez5/bluez5-device.c:1236
 #, c-format
 msgid "Headset Head Unit (HSP/HFP, codec %s)"
 msgstr "Kulaklık Ana Birimi (HSP/HFP, çözücü %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1221
+#: spa/plugins/bluez5/bluez5-device.c:1241
 msgid "Headset Head Unit (HSP/HFP)"
 msgstr "Kulaklık Ana Birimi (HSP/HFP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1297
+#: spa/plugins/bluez5/bluez5-device.c:1323
 msgid "Handsfree"
 msgstr "Ahizesiz"
 
-#: spa/plugins/bluez5/bluez5-device.c:1312
+#: spa/plugins/bluez5/bluez5-device.c:1338
 msgid "Headphone"
 msgstr "Kulaklık"
 
-#: spa/plugins/bluez5/bluez5-device.c:1317
+#: spa/plugins/bluez5/bluez5-device.c:1343
 msgid "Portable"
 msgstr "Taşınabilir"
 
-#: spa/plugins/bluez5/bluez5-device.c:1322
+#: spa/plugins/bluez5/bluez5-device.c:1348
 msgid "Car"
 msgstr "Araba"
 
-#: spa/plugins/bluez5/bluez5-device.c:1327
+#: spa/plugins/bluez5/bluez5-device.c:1353
 msgid "HiFi"
 msgstr "Yüksek Kalite"
 
-#: spa/plugins/bluez5/bluez5-device.c:1332
+#: spa/plugins/bluez5/bluez5-device.c:1358
 msgid "Phone"
 msgstr "Telefon"
 
-#: spa/plugins/bluez5/bluez5-device.c:1338
+#: spa/plugins/bluez5/bluez5-device.c:1364
 msgid "Bluetooth"
 msgstr "Bluetooth"

pipewire-0.3.51.tar.gz/po/uk.po -> pipewire-0.3.52.tar.gz/po/uk.po Changed

@@ -1,23 +1,25 @@
 # Copyright (C) 2009 Free Software Foundation, Inc.
 # This file is distributed under the same license as the pipewire package.
 #
-# Yuri Chornoivan <yurchor@ukr.net>, 2009-2021.
+# Yuri Chornoivan <yurchor@ukr.net>, 2009-2021, 2022.
 msgid ""
 msgstr ""
 "Project-Id-Version: pipewire\n"
-"Report-Msgid-Bugs-To: https://gitlab.freedesktop.org/pipewire/pipewire/-/issues\n"
-"POT-Creation-Date: 2021-09-21 15:31+0000\n"
-"PO-Revision-Date: 2021-09-23 12:37+0300\n"
+"Report-Msgid-Bugs-To: https://gitlab.freedesktop.org/pipewire/pipewire/-/issue"
+"s\n"
+"POT-Creation-Date: 2022-05-05 03:28+0000\n"
+"PO-Revision-Date: 2022-05-05 21:06+0300\n"
 "Last-Translator: Yuri Chornoivan <yurchor@ukr.net>\n"
 "Language-Team: Ukrainian <trans-uk@lists.fedoraproject.org>\n"
 "Language: uk\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
+"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<"
+"=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
 "X-Generator: Lokalize 20.12.0\n"
 
-#: src/daemon/pipewire.c:45
+#: src/daemon/pipewire.c:46
 #, c-format
 msgid ""
 "%s options\n"
@@ -39,43 +41,37 @@
 msgid "Start the PipeWire Media System"
 msgstr "Запустити мультимедійну систему PipeWire"
 
-#: src/examples/media-session/alsa-monitor.c:656
-#: spa/plugins/alsa/acp/compat.c:189
-msgid "Built-in Audio"
-msgstr "Вбудоване аудіо"
-
-#: src/examples/media-session/alsa-monitor.c:660
-#: spa/plugins/alsa/acp/compat.c:194
-msgid "Modem"
-msgstr "Модем"
-
-#: src/examples/media-session/alsa-monitor.c:669
-#: src/modules/module-zeroconf-discover.c:296
-msgid "Unknown device"
-msgstr "Невідомий пристрій"
-
-#: src/modules/module-protocol-pulse/modules/module-tunnel-sink.c:173
-#: src/modules/module-protocol-pulse/modules/module-tunnel-source.c:173
+#: src/modules/module-protocol-pulse/modules/module-tunnel-sink.c:183
+#: src/modules/module-protocol-pulse/modules/module-tunnel-source.c:183
 #, c-format
 msgid "Tunnel to %s/%s"
 msgstr "Тунель до %s/%s"
 
-#: src/modules/module-pulse-tunnel.c:534
+#: src/modules/module-fallback-sink.c:51
+#| msgid "Game Output"
+msgid "Dummy Output"
+msgstr "Фіктивний вихід"
+
+#: src/modules/module-pulse-tunnel.c:639
 #, c-format
 msgid "Tunnel for %s@%s"
 msgstr "Тунель для %s@%s"
 
-#: src/modules/module-zeroconf-discover.c:308
+#: src/modules/module-zeroconf-discover.c:332
+msgid "Unknown device"
+msgstr "Невідомий пристрій"
+
+#: src/modules/module-zeroconf-discover.c:344
 #, c-format
 msgid "%s on %s@%s"
 msgstr "%s на %s@%s"
 
-#: src/modules/module-zeroconf-discover.c:312
+#: src/modules/module-zeroconf-discover.c:348
 #, c-format
 msgid "%s on %s"
 msgstr "%s на %s"
 
-#: src/tools/pw-cat.c:1055
+#: src/tools/pw-cat.c:871
 #, c-format
 msgid ""
 "%s options <file>\n"
@@ -91,8 +87,23 @@
 "інформації\n"
 "\n"
 
-#: src/tools/pw-cat.c:1062
+#: src/tools/pw-cat.c:878
 #, c-format
+#| msgid ""
+#| "  -R, --remote                          Remote daemon name\n"
+#| "      --media-type                      Set media type (default %s)\n"
+#| "      --media-category                  Set media category (default %s)\n"
+#| "      --media-role                      Set media role (default %s)\n"
+#| "      --target                          Set node target (default %s)\n"
+#| "                                          0 means don't link\n"
+#| "      --latency                         Set node latency (default %s)\n"
+#| "                                          Xunit (unit = s, ms, us, ns)\n"
+#| "                                          or direct samples (256)\n"
+#| "                                          the rate is the one of the "
+#| "source file\n"
+#| "      --list-targets                    List available targets for --"
+#| "target\n"
+#| "\n"
 msgid ""
 "  -R, --remote                          Remote daemon name\n"
 "      --media-type                      Set media type (default %s)\n"
@@ -105,7 +116,6 @@
 "                                          or direct samples (256)\n"
 "                                          the rate is the one of the source "
 "file\n"
-"      --list-targets                    List available targets for --target\n"
 "\n"
 msgstr ""
 "  -R, --remote                          назва віддаленої фонової служби\n"
@@ -123,11 +133,9 @@
 "ns)\n"
 "                                          або безпосередні семпли (256)\n"
 "                                          частота — частота з файла джерела\n"
-"      --list-targets                    перерахувати доступні цілі для --"
-"target\n"
 "\n"
 
-#: src/tools/pw-cat.c:1080
+#: src/tools/pw-cat.c:895
 #, c-format
 msgid ""
 "      --rate                            Sample rate (req. for rec) (default "
@@ -163,12 +171,7 @@
 "(типово, %d)\n"
 "\n"
 
-#: src/tools/pw-cat.c:1097
-#| msgid ""
-#| "  -p, --playback                        Playback mode\n"
-#| "  -r, --record                          Recording mode\n"
-#| "  -m, --midi                            Midi mode\n"
-#| "\n"
+#: src/tools/pw-cat.c:912
 msgid ""
 "  -p, --playback                        Playback mode\n"
 "  -r, --record                          Recording mode\n"
@@ -182,7 +185,7 @@
 "  -d, --dsd                             режим DSD\n"
 "\n"
 
-#: src/tools/pw-cli.c:2954
+#: src/tools/pw-cli.c:3139
 #, c-format
 msgid ""
 "%s options command\n"
@@ -200,12 +203,12 @@
 "  -r, --remote                          назва віддаленої фонової служби\n"
 "\n"
 
-#: spa/plugins/alsa/acp/acp.c:310
+#: spa/plugins/alsa/acp/acp.c:321
 msgid "Pro Audio"
 msgstr "Професійний звук"
 
-#: spa/plugins/alsa/acp/acp.c:433 spa/plugins/alsa/acp/alsa-mixer.c:4648
-#: spa/plugins/bluez5/bluez5-device.c:1135
+#: spa/plugins/alsa/acp/acp.c:444 spa/plugins/alsa/acp/alsa-mixer.c:4648
+#: spa/plugins/bluez5/bluez5-device.c:1161
 msgid "Off"
 msgstr "Вимкнено"
 
@@ -232,7 +235,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2657
 #: spa/plugins/alsa/acp/alsa-mixer.c:2741
-#: spa/plugins/bluez5/bluez5-device.c:1292
+#: spa/plugins/bluez5/bluez5-device.c:1330
 msgid "Microphone"
 msgstr "Мікрофон"
 
@@ -298,7 +301,7 @@
 msgstr "Без підсилення"
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:2672
-#: spa/plugins/bluez5/bluez5-device.c:1297
+#: spa/plugins/bluez5/bluez5-device.c:1335
 msgid "Speaker"
 msgstr "Динамік"
 
@@ -413,7 +416,7 @@
 
 #: spa/plugins/alsa/acp/alsa-mixer.c:4484
 #: spa/plugins/alsa/acp/alsa-mixer.c:4642
-#: spa/plugins/bluez5/bluez5-device.c:1282
+#: spa/plugins/bluez5/bluez5-device.c:1320
 msgid "Headset"
 msgstr "Гарнітура"
 
@@ -527,12 +530,12 @@
 msgid "Mono Chat + 7.1 Surround"
 msgstr "Моно, спілкування + об'ємний 7.1"
 
-#: spa/plugins/alsa/acp/alsa-mixer.c:4750
+#: spa/plugins/alsa/acp/alsa-mixer.c:4754
 #, c-format
 msgid "%s Output"
 msgstr "%s-вихід"
 
-#: spa/plugins/alsa/acp/alsa-mixer.c:4757
+#: spa/plugins/alsa/acp/alsa-mixer.c:4761
 #, c-format
 msgid "%s Input"
 msgstr "%s-вхід"
@@ -634,65 +637,73 @@
 "Ймовірно, ви натрапили на помилку у драйвері ALSA «%s». Будь ласка, "
 "повідомте про цю помилку розробникам ALSA."
 
-#: spa/plugins/alsa/acp/channelmap.h:466
+#: spa/plugins/alsa/acp/channelmap.h:464
 msgid "(invalid)"
 msgstr "(некоректний)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1145
+#: spa/plugins/alsa/acp/compat.c:189
+msgid "Built-in Audio"
+msgstr "Вбудоване аудіо"
+
+#: spa/plugins/alsa/acp/compat.c:194
+msgid "Modem"
+msgstr "Модем"
+
+#: spa/plugins/bluez5/bluez5-device.c:1172
 msgid "Audio Gateway (A2DP Source & HSP/HFP AG)"
 msgstr "Звуковий шлюз (джерело A2DP і HSP/HFP AG)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1168
+#: spa/plugins/bluez5/bluez5-device.c:1197
 #, c-format
 msgid "High Fidelity Playback (A2DP Sink, codec %s)"
 msgstr "Високоточне відтворення (приймач A2DP, кодек %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1171
+#: spa/plugins/bluez5/bluez5-device.c:1200
 #, c-format
 msgid "High Fidelity Duplex (A2DP Source/Sink, codec %s)"
 msgstr "Двобічний високоточний обмін (джерело/приймач A2DP, кодек %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1178
+#: spa/plugins/bluez5/bluez5-device.c:1208
 msgid "High Fidelity Playback (A2DP Sink)"
 msgstr "Високоточне відтворення (приймач A2DP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1180
+#: spa/plugins/bluez5/bluez5-device.c:1210
 msgid "High Fidelity Duplex (A2DP Source/Sink)"
 msgstr "Двобічний високоточний обмін (джерело/приймач A2DP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1207
+#: spa/plugins/bluez5/bluez5-device.c:1238
 #, c-format
 msgid "Headset Head Unit (HSP/HFP, codec %s)"
 msgstr "Головний модуль гарнітури (HSP/HFP, кодек %s)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1211
+#: spa/plugins/bluez5/bluez5-device.c:1243
 msgid "Headset Head Unit (HSP/HFP)"
 msgstr "Головний модуль гарнітури (HSP/HFP)"
 
-#: spa/plugins/bluez5/bluez5-device.c:1287
+#: spa/plugins/bluez5/bluez5-device.c:1325
 msgid "Handsfree"
 msgstr "Hands-Free пристрій"
 
-#: spa/plugins/bluez5/bluez5-device.c:1302
+#: spa/plugins/bluez5/bluez5-device.c:1340
 msgid "Headphone"
 msgstr "Навушники"
 
-#: spa/plugins/bluez5/bluez5-device.c:1307
+#: spa/plugins/bluez5/bluez5-device.c:1345
 msgid "Portable"
 msgstr "Портативна акустика"
 
-#: spa/plugins/bluez5/bluez5-device.c:1312
+#: spa/plugins/bluez5/bluez5-device.c:1350
 msgid "Car"
 msgstr "Автомобільна акустика"
 
-#: spa/plugins/bluez5/bluez5-device.c:1317
+#: spa/plugins/bluez5/bluez5-device.c:1355
 msgid "HiFi"
 msgstr "Hi-Fi"
 
-#: spa/plugins/bluez5/bluez5-device.c:1322
+#: spa/plugins/bluez5/bluez5-device.c:1360
 msgid "Phone"
 msgstr "Телефон"
 
-#: spa/plugins/bluez5/bluez5-device.c:1328
+#: spa/plugins/bluez5/bluez5-device.c:1366
 msgid "Bluetooth"
 msgstr "Bluetooth"

pipewire-0.3.51.tar.gz/spa/include/spa/param/bluetooth/audio.h -> pipewire-0.3.52.tar.gz/spa/include/spa/param/bluetooth/audio.h Changed

pipewire-0.3.51.tar.gz/spa/include/spa/param/bluetooth/type-info.h -> pipewire-0.3.52.tar.gz/spa/include/spa/param/bluetooth/type-info.h Changed

pipewire-0.3.51.tar.gz/spa/include/spa/utils/keys.h -> pipewire-0.3.52.tar.gz/spa/include/spa/utils/keys.h Changed

pipewire-0.3.51.tar.gz/spa/include/spa/utils/names.h -> pipewire-0.3.52.tar.gz/spa/include/spa/utils/names.h Changed

pipewire-0.3.51.tar.gz/spa/include/spa/utils/string.h -> pipewire-0.3.52.tar.gz/spa/include/spa/utils/string.h Changed

pipewire-0.3.51.tar.gz/spa/meson.build -> pipewire-0.3.52.tar.gz/spa/meson.build Changed

pipewire-0.3.51.tar.gz/spa/plugins/alsa/90-pipewire-alsa.rules -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/90-pipewire-alsa.rules Changed

@@ -107,6 +107,8 @@
 
 
 ATTRS{idVendor}=="17cc", ATTRS{idProduct}=="1001", ENV{ACP_PROFILE_SET}="native-instruments-komplete-audio6.conf"
+# This entry is for the Komplete Audio 6 MK2, which has a different ID, but is functionally identical to the Komplete Audio 6.
+ATTRS{idVendor}=="17cc", ATTRS{idProduct}=="1870", ENV{ACP_PROFILE_SET}="native-instruments-komplete-audio6.conf"
 ATTRS{idVendor}=="17cc", ATTRS{idProduct}=="1021", ENV{ACP_PROFILE_SET}="native-instruments-traktor-audio10.conf"
 ATTRS{idVendor}=="0763", ATTRS{idProduct}=="2012", ENV{ACP_PROFILE_SET}="maudio-fasttrack-pro.conf"
 ATTRS{idVendor}=="045e", ATTRS{idProduct}=="02bb", ENV{ACP_PROFILE_SET}="kinect-audio.conf"
@@ -131,6 +133,8 @@
 ATTRS{idVendor}=="2f12", ATTRS{idProduct}=="0109", ENV{ACP_PROFILE_SET}="usb-gaming-headset.conf"
 # ID 9886:002c is for the Astro A50 Gen4
 ATTRS{idVendor}=="9886", ATTRS{idProduct}=="002c", ENV{ACP_PROFILE_SET}="usb-gaming-headset.conf"
+# ID 9886:0045 is for the Astro A20 Gen2
+ATTRS{idVendor}=="9886", ATTRS{idProduct}=="0045", ENV{ACP_PROFILE_SET}="usb-gaming-headset.conf"
 # ID 1532:0520 is for the Razer Kraken Tournament Edition
 ATTRS{idVendor}=="1532", ATTRS{idProduct}=="0520", ENV{ACP_PROFILE_SET}="usb-gaming-headset.conf"

pipewire-0.3.51.tar.gz/spa/plugins/alsa/acp/acp.c -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/acp/acp.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/alsa/acp/channelmap.h -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/acp/channelmap.h Changed

pipewire-0.3.51.tar.gz/spa/plugins/alsa/alsa-pcm-sink.c -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/alsa-pcm-sink.c Changed

@@ -353,7 +353,9 @@
 	case SPA_PARAM_ProcessLatency:
 	{
 		struct spa_process_latency_info info;
-		if ((res = spa_process_latency_parse(param, &info)) < 0)
+		if (param == NULL)
+			spa_zero(info);
+		else if ((res = spa_process_latency_parse(param, &info)) < 0)
 			return res;
 
 		handle_process_latency(this, &info);
@@ -531,8 +533,8 @@
 			SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
 			SPA_PARAM_BUFFERS_blocks,  SPA_POD_Int(this->blocks),
 			SPA_PARAM_BUFFERS_size,    SPA_POD_CHOICE_RANGE_Int(
-							this->quantum_limit * this->frame_size,
-							16 * this->frame_size,
+							this->quantum_limit * this->frame_size * this->frame_scale,
+							16 * this->frame_size * this->frame_scale,
 							INT32_MAX),
 			SPA_PARAM_BUFFERS_stride,  SPA_POD_Int(this->frame_size));
 		break;
@@ -694,7 +696,9 @@
 	case SPA_PARAM_Latency:
 	{
 		struct spa_latency_info info;
-		if ((res = spa_latency_parse(param, &info)) < 0)
+		if (param == NULL)
+			info = SPA_LATENCY_INFO(SPA_DIRECTION_REVERSE(direction));
+		else if ((res = spa_latency_parse(param, &info)) < 0)
 			return res;
 		if (direction == info.direction)
 			return -EINVAL;

pipewire-0.3.51.tar.gz/spa/plugins/alsa/alsa-pcm-source.c -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/alsa-pcm-source.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/alsa/alsa-pcm.c -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/alsa-pcm.c Changed

@@ -466,7 +466,9 @@
 	}
 	if (state->clock_name0 == '\0')
 		snprintf(state->clock_name, sizeof(state->clock_name),
-				"api.alsa.%u", state->card_index);
+				"api.alsa.%s-%u",
+				state->stream == SND_PCM_STREAM_PLAYBACK ? "p" : "c",
+				state->card_index);
 
 	if (state->stream == SND_PCM_STREAM_PLAYBACK) {
 		state->is_iec958 = spa_strstartswith(state->props.device, "iec958");
@@ -1235,7 +1237,7 @@
 
 int spa_alsa_set_format(struct state *state, struct spa_audio_info *fmt, uint32_t flags)
 {
-	unsigned int rrate, rchannels, val;
+	unsigned int rrate, rchannels, val, rscale = 1;
 	snd_pcm_uframes_t period_size;
 	int err, dir;
 	snd_pcm_hw_params_t *params;
@@ -1322,21 +1324,26 @@
 		case 4:
 			rformat = SND_PCM_FORMAT_DSD_U32_BE;
 			rrate /= 4;
+			rscale = 4;
 			break;
 		case -4:
 			rformat = SND_PCM_FORMAT_DSD_U32_LE;
 			rrate /= 4;
+			rscale = 4;
 			break;
 		case 2:
 			rformat = SND_PCM_FORMAT_DSD_U16_BE;
 			rrate /= 2;
+			rscale = 2;
 			break;
 		case -2:
 			rformat = SND_PCM_FORMAT_DSD_U16_LE;
 			rrate /= 2;
+			rscale = 2;
 			break;
 		case 1:
 			rformat = SND_PCM_FORMAT_DSD_U8;
+			rscale = 1;
 			break;
 		default:
 			return -ENOTSUP;
@@ -1430,6 +1437,7 @@
 	state->channels = rchannels;
 	state->rate = rrate;
 	state->frame_size = snd_pcm_format_physical_width(rformat) / 8;
+	state->frame_scale = rscale;
 	state->planar = planar;
 	state->blocks = 1;
 	if (planar)
@@ -1477,7 +1485,7 @@
 	} else {
 		CHECK(snd_pcm_hw_params_get_buffer_size_max(params, &state->buffer_frames), "get_buffer_size_max");
 
-		state->buffer_frames = SPA_MIN(state->buffer_frames, state->quantum_limit * 4);
+		state->buffer_frames = SPA_MIN(state->buffer_frames, state->quantum_limit * 4)* state->frame_scale;
 
 		CHECK(snd_pcm_hw_params_set_buffer_size_min(hndl, params, &state->buffer_frames), "set_buffer_size_min");
 		CHECK(snd_pcm_hw_params_set_buffer_size_near(hndl, params, &state->buffer_frames), "set_buffer_size_near");
@@ -1785,9 +1793,11 @@
 	if (err > state->max_error) {
 		err = state->max_error;
 		state->alsa_sync = true;
+		state->alsa_sync_warning = (diff == 0);
 	} else if (err < -state->max_error) {
 		err = -state->max_error;
 		state->alsa_sync = true;
+		state->alsa_sync_warning = (diff == 0);
 	}
 
 	if (!follower || state->matching)
@@ -1854,6 +1864,11 @@
 		state->matching = false;
 
 	state->resample = ((uint32_t)state->rate != state->rate_denom) || state->matching;
+
+	spa_log_info(state->log, "driver clock:'%s'@%d our clock:'%s'@%d matching:%d resample:%d",
+			state->position->clock.name, state->rate_denom,
+			state->clock_name, state->rate,
+			state->matching, state->resample);
 	return 0;
 }
 
@@ -1867,6 +1882,7 @@
 		state->duration = state->position->clock.duration;
 		state->rate_denom = state->position->clock.rate.denom;
 		state->threshold = (state->duration * state->rate + state->rate_denom-1) / state->rate_denom;
+		state->max_error = SPA_MAX(256.0f, state->threshold / 2.0f);
 		state->resample = ((uint32_t)state->rate != state->rate_denom) || state->matching;
 		state->alsa_sync = true;
 	}
@@ -1893,9 +1909,18 @@
 		if (SPA_UNLIKELY((res = get_status(state, current_time, &delay, &target)) < 0))
 			return res;
 
+		if (SPA_UNLIKELY((res = update_time(state, current_time, delay, target, true)) < 0))
+			return res;
+
 		if (SPA_UNLIKELY(state->alsa_sync)) {
-			spa_log_warn(state->log, "%s: follower delay:%ld target:%ld thr:%u, resync",
-					state->props.device, delay, target, state->threshold);
+			if (SPA_UNLIKELY(state->alsa_sync_warning)) {
+				spa_log_warn(state->log, "%s: follower delay:%ld target:%ld thr:%u, resync",
+						state->props.device, delay, target, state->threshold);
+				state->alsa_sync_warning = false;
+			} else
+				spa_log_info(state->log, "%s: follower delay:%ld target:%ld thr:%u, resync",
+						state->props.device, delay, target, state->threshold);
+
 			if (delay > target)
 				snd_pcm_rewind(state->hndl, delay - target);
 			else if (delay < target)
@@ -1903,8 +1928,6 @@
 			delay = target;
 			state->alsa_sync = false;
 		}
-		if (SPA_UNLIKELY((res = update_time(state, current_time, delay, target, true)) < 0))
-			return res;
 	}
 
 	total_written = 0;
@@ -2131,9 +2154,18 @@
 
 		avail = delay;
 
+		if (SPA_UNLIKELY((res = update_time(state, current_time, delay, target, true)) < 0))
+			return res;
+
 		if (state->alsa_sync) {
-			spa_log_warn(state->log, "%s: follower delay:%lu target:%lu thr:%u, resync",
-					state->props.device, delay, target, threshold);
+			if (SPA_UNLIKELY(state->alsa_sync_warning)) {
+				spa_log_warn(state->log, "%s: follower delay:%lu target:%lu thr:%u, resync",
+						state->props.device, delay, target, threshold);
+				state->alsa_sync_warning = false;
+			} else
+				spa_log_info(state->log, "%s: follower delay:%lu target:%lu thr:%u, resync",
+						state->props.device, delay, target, threshold);
+
 			if (delay < target)
 				max_read = target - delay;
 			else if (delay > target)
@@ -2142,9 +2174,6 @@
 			state->alsa_sync = false;
 		}
 
-		if ((res = update_time(state, current_time, delay, target, true)) < 0)
-			return res;
-
 		if (avail < state->read_size)
 			max_read = 0;
 	}
@@ -2406,11 +2435,10 @@
 	state->following = is_following(state);
 	setup_matching(state);
 
+	spa_dll_init(&state->dll);
 	state->threshold = (state->duration * state->rate + state->rate_denom-1) / state->rate_denom;
 	state->last_threshold = state->threshold;
-
-	spa_dll_init(&state->dll);
-	state->max_error = (256.0 * state->rate) / state->rate_denom;
+	state->max_error = SPA_MAX(256.0f, state->threshold / 2.0f);
 
 	spa_log_debug(state->log, "%p: start %d duration:%d rate:%d follower:%d match:%d resample:%d",
 			state, state->threshold, state->duration, state->rate_denom,

pipewire-0.3.51.tar.gz/spa/plugins/alsa/alsa-pcm.h -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/alsa-pcm.h Changed

pipewire-0.3.51.tar.gz/spa/plugins/alsa/mixer/profile-sets/native-instruments-komplete-audio6.conf -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/mixer/profile-sets/native-instruments-komplete-audio6.conf Changed

pipewire-0.3.51.tar.gz/spa/plugins/alsa/mixer/profile-sets/texas-instruments-pcm2902.conf -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/mixer/profile-sets/texas-instruments-pcm2902.conf Changed

pipewire-0.3.51.tar.gz/spa/plugins/alsa/test-timer.c -> pipewire-0.3.52.tar.gz/spa/plugins/alsa/test-timer.c Changed

@@ -32,15 +32,13 @@
 #include <alsa/asoundlib.h>
 
 #include <spa/utils/dll.h>
+#include <spa/utils/defs.h>
 
 #define DEFAULT_DEVICE	"hw:0"
 
 #define M_PI_M2 (M_PI + M_PI)
 
-#define NSEC_PER_SEC	1000000000ll
-#define TIMESPEC_TO_NSEC(ts) ((ts)->tv_sec * NSEC_PER_SEC + (ts)->tv_nsec)
-
-#define BW_PERIOD	(NSEC_PER_SEC * 3)
+#define BW_PERIOD	(SPA_NSEC_PER_SEC * 3)
 
 struct state {
 	const char *device;
@@ -65,8 +63,8 @@
 static int set_timeout(struct state *state, uint64_t time)
 {
 	struct itimerspec ts;
-	ts.it_value.tv_sec = time / NSEC_PER_SEC;
-	ts.it_value.tv_nsec = time % NSEC_PER_SEC;
+	ts.it_value.tv_sec = time / SPA_NSEC_PER_SEC;
+	ts.it_value.tv_nsec = time % SPA_NSEC_PER_SEC;
 	ts.it_interval.tv_sec = 0;
 	ts.it_interval.tv_nsec = 0;
 	return timerfd_settime(state->timerfd, TFD_TIMER_ABSTIME, &ts, NULL);
@@ -133,12 +131,12 @@
 	CHECK(snd_pcm_htimestamp(state->hndl, &avail, &tstamp), "htimestamp");
 	delay = state->buffer_frames - avail;
 
-	then = TIMESPEC_TO_NSEC(&tstamp);
+	then = SPA_TIMESPEC_TO_NSEC(&tstamp);
 	if (then != 0) {
 		if (then < state->next_time) {
-			delay -= (state->next_time - then) * state->rate / NSEC_PER_SEC;
+			delay -= (state->next_time - then) * state->rate / SPA_NSEC_PER_SEC;
 		} else {
-			delay += (then - state->next_time) * state->rate / NSEC_PER_SEC;
+			delay += (then - state->next_time) * state->rate / SPA_NSEC_PER_SEC;
 		}
 	}
 #endif
@@ -278,7 +276,7 @@
 
 	spa_dll_init(&state.dll);
 	spa_dll_set_bw(&state.dll, SPA_DLL_BW_MAX, state.period, state.rate);
-	state.max_error = 256.0;
+	state.max_error = SPA_MAX(256.0, state.period / 2.0f);
 
 	if ((state.timerfd = timerfd_create(CLOCK_MONOTONIC, 0)) < 0)
 		perror("timerfd");
@@ -290,7 +288,7 @@
 
 	/* set our first timeout for now */
 	clock_gettime(CLOCK_MONOTONIC, &now);
-	state.prev_time = state.next_time = TIMESPEC_TO_NSEC(&now);
+	state.prev_time = state.next_time = SPA_TIMESPEC_TO_NSEC(&now);
 	set_timeout(&state, state.next_time);
 
 	/* and start playback */

pipewire-0.3.51.tar.gz/spa/plugins/audioconvert/audioadapter.c -> pipewire-0.3.52.tar.gz/spa/plugins/audioconvert/audioadapter.c Changed

@@ -257,6 +257,9 @@
 	uint32_t i;
 	uint64_t old = full ? this->info.change_mask : 0;
 
+	spa_log_debug(this->log, "%p: info full:%d change:%08"PRIx64,
+			this, full, this->info.change_mask);
+
 	if (full)
 		this->info.change_mask = this->info_all;
 	if (this->info.change_mask) {
@@ -265,6 +268,8 @@
 				if (this->paramsi.user > 0) {
 					this->paramsi.flags ^= SPA_PARAM_INFO_SERIAL;
 					this->paramsi.user = 0;
+					spa_log_debug(this->log, "param %d flags:%08x",
+							i, this->paramsi.flags);
 				}
 			}
 		}
@@ -277,38 +282,45 @@
                 enum spa_direction direction, uint32_t port_id, uint32_t id, struct spa_pod *filter,
 		const char *debug, int err)
 {
-        struct spa_pod_builder b = { 0 };
-        uint8_t buffer4096;
-        uint32_t state;
-        struct spa_pod *param;
-        int res;
+	struct spa_pod_builder b = { 0 };
+	uint8_t buffer4096;
+	uint32_t state;
+	struct spa_pod *param;
+	int res, count = 0;
 
-        spa_log_error(this->log, "params %s: %d:%d (%s) %s",
+	spa_log_error(this->log, "params %s: %d:%d (%s) %s",
 			spa_debug_type_find_name(spa_type_param, id),
-			direction, port_id, debug, spa_strerror(err));
+			direction, port_id, debug, err ? spa_strerror(err) : "no matching params");
 	if (err == -EBUSY)
 		return 0;
 
-        state = 0;
-        while (true) {
-                spa_pod_builder_init(&b, buffer, sizeof(buffer));
-                res = spa_node_port_enum_params_sync(node,
-                                       direction, port_id,
-                                       id, &state,
-                                       NULL, &param, &b);
-                if (res != 1) {
+	if (filter) {
+		spa_log_error(this->log, "with this filter:");
+		spa_debug_pod(2, NULL, filter);
+	} else {
+		spa_log_error(this->log, "there was no filter");
+	}
+
+	state = 0;
+	while (true) {
+		spa_pod_builder_init(&b, buffer, sizeof(buffer));
+		res = spa_node_port_enum_params_sync(node,
+					direction, port_id,
+					id, &state,
+					NULL, &param, &b);
+		if (res != 1) {
 			if (res < 0)
 				spa_log_error(this->log, "  error: %s", spa_strerror(res));
-                        break;
+			break;
 		}
-                spa_debug_pod(2, NULL, param);
-        }
-
-        spa_log_error(this->log, "failed filter:");
-        if (filter)
-                spa_debug_pod(2, NULL, filter);
+		spa_log_error(this->log, "unmatched %s %d:", debug, count);
+		spa_debug_pod(2, NULL, param);
+		count++;
+	}
+	if (count == 0)
+		spa_log_error(this->log, "could not get any %s", debug);
 
-        return 0;
+	return 0;
 }
 
 static int negotiate_buffers(struct impl *this)
@@ -832,6 +844,9 @@
 	struct impl *this = data;
 	uint32_t i;
 
+	spa_log_debug(this->log, "%p: info change:%08"PRIx64, this,
+			info->change_mask);
+
 	if (info->change_mask & SPA_NODE_CHANGE_MASK_PARAMS) {
 		for (i = 0; i < info->n_params; i++) {
 			uint32_t idx;
@@ -856,8 +871,10 @@
 				(this->paramsidx.flags & SPA_PARAM_INFO_SERIAL) |
 				(info->paramsi.flags & SPA_PARAM_INFO_READWRITE);
 
-			if (!this->add_listener)
+			if (!this->add_listener) {
 				this->paramsidx.user++;
+				spa_log_debug(this->log, "param %d changed", info->paramsi.id);
+			}
 		}
 	}
 	emit_node_info(this, false);
@@ -876,7 +893,7 @@
 			port_id--;
 	}
 
-	spa_log_trace(this->log, "%p: port info %d:%d", this,
+	spa_log_debug(this->log, "%p: port info %d:%d", this,
 			direction, port_id);
 
 	if (this->target != this->follower)
@@ -906,6 +923,9 @@
 	struct impl *this = data;
 	uint32_t i;
 
+	spa_log_debug(this->log, "%p: info change:%08"PRIx64, this,
+			info->change_mask);
+
 	if (this->follower_removing)
 		return;
 
@@ -959,11 +979,17 @@
 				(this->paramsidx.flags & SPA_PARAM_INFO_SERIAL) |
 				(info->paramsi.flags & SPA_PARAM_INFO_READWRITE);
 
-			if (!this->add_listener)
+			if (!this->add_listener) {
 				this->paramsidx.user++;
+				spa_log_debug(this->log, "param %d changed", info->paramsi.id);
+			}
 		}
 	}
 	emit_node_info(this, false);
+
+	spa_zero(this->info.props);
+	this->info.change_mask &= ~SPA_NODE_CHANGE_MASK_PROPS;
+
 }
 
 static int recalc_latency(struct impl *this, enum spa_direction direction, uint32_t port_id)
@@ -1044,12 +1070,15 @@
 
 			if (idx == IDX_Latency) {
 				res = recalc_latency(this, direction, port_id);
-				spa_log_debug(this->log, "latency: %d", res);
+				spa_log_debug(this->log, "latency: %d (%s)", res,
+						spa_strerror(res));
 			}
 
 			this->info.change_mask |= SPA_NODE_CHANGE_MASK_PARAMS;
-			if (!this->add_listener)
+			if (!this->add_listener) {
 				this->paramsidx.user++;
+				spa_log_debug(this->log, "param %d changed", info->paramsi.id);
+			}
 		}
 	}
 	emit_node_info(this, false);
@@ -1069,11 +1098,29 @@
 	spa_node_emit_result(&this->hooks, seq, res, type, result);
 }
 
+static void follower_event(void *data, const struct spa_event *event)
+{
+	struct impl *this = data;
+
+	spa_log_trace(this->log, "%p: event %d", this, SPA_EVENT_TYPE(event));
+
+	switch (SPA_NODE_EVENT_ID(event)) {
+	case SPA_NODE_EVENT_Error:
+		/* Forward errors */
+		spa_node_emit_event(&this->hooks, event);
+		break;
+	default:
+		/* Ignore other events */
+		break;
+	}
+}
+
 static const struct spa_node_events follower_node_events = {
 	SPA_VERSION_NODE_EVENTS,
 	.info = follower_info,
 	.port_info = follower_port_info,
 	.result = follower_result,
+	.event = follower_event,
 };
 
 static int follower_ready(void *data, int status)
@@ -1313,7 +1360,7 @@
 static int impl_node_process(void *object)
 {
 	struct impl *this = object;
-	int status = 0, fstatus;
+	int status = 0, fstatus, retry = 8;
 
 	spa_log_trace_fp(this->log, "%p: process convert:%p driver:%d",
 			this, this->convert, this->driver);
@@ -1328,7 +1375,7 @@
 		/* an input node (sink).
 		 * First we run the converter to process the input for the follower
 		 * then if it produced data, we run the follower. */
-		while (true) {
+		while (retry--) {
 			status = this->convert ? spa_node_process(this->convert) : 0;
 			/* schedule the follower when the converter needed
 			 * a recycled buffer */
@@ -1357,7 +1404,7 @@
 		}
 	} else if (!this->driver) {
 		bool done = false;
-		while (true) {
+		while (retry--) {
 			/* output node (source). First run the converter to make
 			 * sure we push out any queued data. Then when it needs
 			 * more data, schedule the follower. */

pipewire-0.3.51.tar.gz/spa/plugins/audioconvert/audioconvert.c -> pipewire-0.3.52.tar.gz/spa/plugins/audioconvert/audioconvert.c Changed

@@ -614,13 +614,6 @@
 	return res;
 }
 
-static void on_node_result(void *data, int seq, int res, uint32_t type, const void *result)
-{
-	struct impl *this = data;
-	spa_log_trace(this->log, "%p: result %d %d", this, seq, res);
-	spa_node_emit_result(&this->hooks, seq, res, type, result);
-}
-
 static void fmt_input_port_info(void *data,
 		enum spa_direction direction, uint32_t port,
 		const struct spa_port_info *info)
@@ -642,7 +635,6 @@
 static const struct spa_node_events fmt_input_events = {
 	SPA_VERSION_NODE_EVENTS,
 	.port_info = fmt_input_port_info,
-	.result = on_node_result,
 };
 
 static void fmt_output_port_info(void *data,
@@ -663,7 +655,6 @@
 static const struct spa_node_events fmt_output_events = {
 	SPA_VERSION_NODE_EVENTS,
 	.port_info = fmt_output_port_info,
-	.result = on_node_result,
 };
 
 static void on_channelmix_info(void *data, const struct spa_node_info *info)
@@ -706,12 +697,6 @@
 static const struct spa_node_events channelmix_events = {
 	SPA_VERSION_NODE_EVENTS,
 	.info = on_channelmix_info,
-	.result = on_node_result,
-};
-
-static const struct spa_node_events proxy_events = {
-	SPA_VERSION_NODE_EVENTS,
-	.result = on_node_result,
 };
 
 static int reconfigure_mode(struct impl *this, enum spa_param_port_config_mode mode,
@@ -1020,6 +1005,7 @@
 	uint8_t buffer4096;
 	struct spa_result_node_params result;
 	uint32_t count = 0;
+	int res;
 
 	spa_return_val_if_fail(this != NULL, -EINVAL);
 	spa_return_val_if_fail(num != 0, -EINVAL);
@@ -1029,24 +1015,11 @@
 	result.id = id;
 	result.next = start;
       next:
-	result.index = result.next++;
+	result.index = result.next;
 
 	spa_pod_builder_init(&b, buffer, sizeof(buffer));
 
 	switch (id) {
-	case SPA_PARAM_PropInfo:
-		switch (result.index) {
-		case 0:
-			param = spa_pod_builder_add_object(&b,
-				SPA_TYPE_OBJECT_PropInfo, id,
-				SPA_PROP_INFO_id,   SPA_POD_Id(SPA_PROP_volume),
-				SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Float(1.0, 0.0, 10.0));
-			break;
-		default:
-			return 0;
-		}
-		break;
-
 	case SPA_PARAM_IO:
 		switch (result.index) {
 		case 0:
@@ -1064,6 +1037,7 @@
 		default:
 			return 0;
 		}
+		result.next++;
 		break;
 	default:
 	{
@@ -1074,8 +1048,12 @@
 		else
 			target = this->fmtdirection;
 
-		return spa_node_port_enum_params(target, seq, direction, port_id,
-			id, start, num, filter);
+		res = spa_node_port_enum_params_sync(target,
+				       direction, port_id,
+				       id, &result.next,
+				       NULL, &param, &b);
+		if (res != 1)
+			return res;
 	}
 	}
 
@@ -1424,8 +1402,6 @@
 
 	spa_node_add_listener(this->channelmix,
 			&this->listener0, &channelmix_events, this);
-	spa_node_add_listener(this->merger,
-			&this->listener1, &proxy_events, this);
 
 	return 0;
 }

pipewire-0.3.51.tar.gz/spa/plugins/audioconvert/resample.c -> pipewire-0.3.52.tar.gz/spa/plugins/audioconvert/resample.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/audiomixer/mix-ops-avx.c -> pipewire-0.3.52.tar.gz/spa/plugins/audiomixer/mix-ops-avx.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/audiomixer/mix-ops-c.c -> pipewire-0.3.52.tar.gz/spa/plugins/audiomixer/mix-ops-c.c Changed

@@ -40,7 +40,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(int8_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int8_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int8_t));
 
 	for (i = 1; i < n_src; i++) {
 		const int8_t *s = srci;
@@ -59,7 +59,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(uint8_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint8_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint8_t));
 
 	for (i = 1; i < n_src; i++) {
 		const uint8_t *s = srci;
@@ -78,7 +78,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(int16_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int16_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int16_t));
 
 	for (i = 1; i < n_src; i++) {
 		const int16_t *s = srci;
@@ -97,7 +97,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(uint16_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint16_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint16_t));
 
 	for (i = 1; i < n_src; i++) {
 		const uint16_t *s = srci;
@@ -116,7 +116,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(uint8_t) * 3);
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint8_t) * 3);
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint8_t) * 3);
 
 	for (i = 1; i < n_src; i++) {
 		const uint8_t *s = srci;
@@ -138,7 +138,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(uint8_t) * 3);
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint8_t) * 3);
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint8_t) * 3);
 
 	for (i = 1; i < n_src; i++) {
 		const uint8_t *s = srci;
@@ -160,7 +160,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(int32_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int32_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int32_t));
 
 	for (i = 1; i < n_src; i++) {
 		const int32_t *s = srci;
@@ -179,7 +179,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(uint32_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint32_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint32_t));
 
 	for (i = 1; i < n_src; i++) {
 		const uint32_t *s = srci;
@@ -198,7 +198,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(int32_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int32_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(int32_t));
 
 	for (i = 1; i < n_src; i++) {
 		const int32_t *s = srci;
@@ -217,7 +217,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(uint32_t));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint32_t));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(uint32_t));
 
 	for (i = 1; i < n_src; i++) {
 		const uint32_t *s = srci;
@@ -236,7 +236,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(float));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(float));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(float));
 
 	for (i = 1; i < n_src; i++) {
 		const float *s = srci;
@@ -255,7 +255,7 @@
 	if (n_src == 0)
 		memset(dst, 0, n_samples * ops->n_channels * sizeof(double));
 	else if (dst != src0)
-		memcpy(dst, src0, n_samples * ops->n_channels * sizeof(double));
+		spa_memcpy(dst, src0, n_samples * ops->n_channels * sizeof(double));
 
 	for (i = 1; i < n_src; i++) {
 		const double *s = srci;

pipewire-0.3.51.tar.gz/spa/plugins/audiomixer/mix-ops-sse.c -> pipewire-0.3.52.tar.gz/spa/plugins/audiomixer/mix-ops-sse.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/audiomixer/mix-ops-sse2.c -> pipewire-0.3.52.tar.gz/spa/plugins/audiomixer/mix-ops-sse2.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/audiomixer/mixer-dsp.c -> pipewire-0.3.52.tar.gz/spa/plugins/audiomixer/mixer-dsp.c Changed

@@ -690,9 +690,9 @@
 		outio->buffer_id = SPA_ID_INVALID;
 	}
 
-        buffers = alloca(MAX_PORTS * sizeof(struct buffer *));
-        datas = alloca(MAX_PORTS * sizeof(void *));
-        n_buffers = 0;
+	buffers = alloca(MAX_PORTS * sizeof(struct buffer *));
+	datas = alloca(MAX_PORTS * sizeof(void *));
+	n_buffers = 0;
 
 	maxsize = UINT32_MAX;
 
@@ -700,6 +700,8 @@
 		struct port *inport = GET_IN_PORT(this, i);
 		struct spa_io_buffers *inio = NULL;
 		struct buffer *inb;
+		struct spa_data *bd;
+		uint32_t size, offs;
 
 		if (SPA_UNLIKELY(!PORT_VALID(inport) ||
 		    (inio = inport->io) == NULL ||
@@ -715,21 +717,26 @@
 		}
 
 		inb = &inport->buffersinio->buffer_id;
-		maxsize = SPA_MIN(inb->buffer->datas0.chunk->size, maxsize);
+		bd = &inb->buffer->datas0;
 
-		spa_log_trace_fp(this->log, "%p: mix input %d %p->%p %d %d %d", this,
-				i, inio, outio, inio->status, inio->buffer_id, maxsize);
+		offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
+		size = SPA_MIN(bd->maxsize - offs, bd->chunk->size);
+		maxsize = SPA_MIN(maxsize, size);
 
-		datasn_buffers = inb->buffer->datas0.data;
+		spa_log_trace_fp(this->log, "%p: mix input %d %p->%p %d %d %d:%d", this,
+				i, inio, outio, inio->status, inio->buffer_id,
+				offs, size);
+
+		datasn_buffers = SPA_PTROFF(bd->data, offs, void);
 		buffersn_buffers++ = inb;
 		inio->status = SPA_STATUS_NEED_DATA;
 	}
 
 	outb = dequeue_buffer(this, outport);
-        if (SPA_UNLIKELY(outb == NULL)) {
-                spa_log_trace(this->log, "%p: out of buffers", this);
-                return -EPIPE;
-        }
+	if (SPA_UNLIKELY(outb == NULL)) {
+		spa_log_trace(this->log, "%p: out of buffers", this);
+		return -EPIPE;
+	}
 
 	if (n_buffers == 1) {
 		*outb->buffer = *buffers0->buffer;
@@ -743,6 +750,8 @@
 		d0.chunk->size = maxsize;
 		d0.chunk->stride = sizeof(float);
 
+		spa_log_trace_fp(this->log, "%p: %d mix %d", this, n_buffers, maxsize);
+
 		mix_ops_process(&this->ops, d0.data,
 				datas, n_buffers, maxsize / sizeof(float));
 	}

pipewire-0.3.51.tar.gz/spa/plugins/audiotestsrc/audiotestsrc.c -> pipewire-0.3.52.tar.gz/spa/plugins/audiotestsrc/audiotestsrc.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-codec-aac.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codec-aac.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-codec-aptx.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codec-aptx.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-codec-caps.h -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codec-caps.h Changed

@@ -202,6 +202,37 @@
 
 #define FASTSTREAM_SOURCE_SAMPLING_FREQ_16000   0x2
 
+#define LC3PLUS_HR_GET_FRAME_DURATION(a) ((a).frame_duration & 0xf0)
+#define LC3PLUS_HR_INIT_FRAME_DURATION(v) \
+	.frame_duration = ((v) & 0xf0),
+#define LC3PLUS_HR_SET_FRAME_DURATION(a, v)		\
+	do {						\
+		(a).frame_duration = ((v) & 0xf0);	\
+	} while (0)
+
+#define LC3PLUS_HR_GET_FREQUENCY(a) (((a).frequency1 << 8) | (a).frequency2)
+#define LC3PLUS_HR_INIT_FREQUENCY(v)		\
+	.frequency1 = (((v) >> 8) & 0xff),	\
+	.frequency2 = ((v) & 0xff),
+#define LC3PLUS_HR_SET_FREQUENCY(a, v)			\
+	do {						\
+		(a).frequency1 = ((v) >> 8) & 0xff;	\
+		(a).frequency2 = (v) & 0xff;		\
+	} while (0)
+
+#define LC3PLUS_HR_VENDOR_ID		0x000008a9
+#define LC3PLUS_HR_CODEC_ID		0x0001
+
+#define LC3PLUS_HR_FRAME_DURATION_10MS	(1 << 6)
+#define LC3PLUS_HR_FRAME_DURATION_5MS	(1 << 5)
+#define LC3PLUS_HR_FRAME_DURATION_2_5MS	(1 << 4)
+
+#define LC3PLUS_HR_CHANNELS_1		(1 << 7)
+#define LC3PLUS_HR_CHANNELS_2		(1 << 6)
+
+#define LC3PLUS_HR_SAMPLING_FREQ_48000	(1 << 8)
+#define LC3PLUS_HR_SAMPLING_FREQ_96000	(1 << 7)
+
 typedef struct {
 	uint32_t vendor_id;
 	uint16_t codec_id;
@@ -352,4 +383,12 @@
         uint8_t good_working_level1;
 } __attribute__ ((packed)) a2dp_aptx_ll_ext_t;
 
+typedef struct {
+        a2dp_vendor_codec_t info;
+	uint8_t frame_duration;
+	uint8_t channels;
+	uint8_t frequency1;
+	uint8_t frequency2;
+} __attribute__ ((packed)) a2dp_lc3plus_hr_t;
+
 #endif

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-codec-faststream.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codec-faststream.c Changed

pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codec-lc3plus.c Added

@@ -0,0 +1,788 @@
+/* Spa A2DP LC3plus HR codec
+ *
+ * Copyright © 2020 Wim Taymans
+ * Copyright © 2022 Pauli Virtanen
+ *
+ * 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 <unistd.h>
+#include <stddef.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#if __BYTE_ORDER != __LITTLE_ENDIAN
+#include <byteswap.h>
+#endif
+
+#include <spa/param/audio/format.h>
+#include <spa/param/audio/format-utils.h>
+
+#ifdef HAVE_LC3PLUS_H
+#include <lc3plus.h>
+#else
+#include <lc3.h>
+#endif
+
+#include "rtp.h"
+#include "a2dp-codecs.h"
+
+#define BITRATE_MIN 96000
+#define BITRATE_MAX 512000
+#define BITRATE_DEFAULT 160000
+
+struct dec_data {
+	int frame_size;
+	int fragment_size;
+	int fragment_count;
+	uint8_t fragmentLC3PLUS_MAX_BYTES;
+};
+
+struct enc_data {
+	struct rtp_header *header;
+	struct rtp_payload *payload;
+
+	int samples;
+	int codesize;
+
+	int packet_size;
+	int fragment_size;
+	int fragment_count;
+	void *fragment;
+
+	int bitrate;
+	int next_bitrate;
+};
+
+struct impl {
+	LC3PLUS_Enc *enc;
+	LC3PLUS_Dec *dec;
+
+	int mtu;
+	int samplerate;
+	int channels;
+	int frame_dms;
+	int bitrate;
+
+	struct dec_data d;
+	struct enc_data e;
+
+	int32_t buf2LC3PLUS_MAX_SAMPLES;
+};
+
+static int codec_fill_caps(const struct a2dp_codec *codec, uint32_t flags,
+		uint8_t capsA2DP_MAX_CAPS_SIZE)
+{
+	const a2dp_lc3plus_hr_t a2dp_lc3plus_hr = {
+		.info = codec->vendor,
+		LC3PLUS_HR_INIT_FRAME_DURATION(LC3PLUS_HR_FRAME_DURATION_10MS
+				| LC3PLUS_HR_FRAME_DURATION_5MS
+				| LC3PLUS_HR_FRAME_DURATION_2_5MS)
+		.channels = LC3PLUS_HR_CHANNELS_1 | LC3PLUS_HR_CHANNELS_2,
+		LC3PLUS_HR_INIT_FREQUENCY(LC3PLUS_HR_SAMPLING_FREQ_48000
+				| (lc3plus_samplerate_supported(96000) ? LC3PLUS_HR_SAMPLING_FREQ_96000 : 0))
+	};
+	memcpy(caps, &a2dp_lc3plus_hr, sizeof(a2dp_lc3plus_hr));
+	return sizeof(a2dp_lc3plus_hr);
+}
+
+static int codec_select_config(const struct a2dp_codec *codec, uint32_t flags,
+		const void *caps, size_t caps_size,
+		const struct a2dp_codec_audio_info *info,
+		const struct spa_dict *settings, uint8_t configA2DP_MAX_CAPS_SIZE)
+{
+	a2dp_lc3plus_hr_t conf;
+
+	if (caps_size < sizeof(conf))
+		return -EINVAL;
+
+	memcpy(&conf, caps, sizeof(conf));
+
+	if (codec->vendor.vendor_id != conf.info.vendor_id ||
+	    codec->vendor.codec_id != conf.info.codec_id)
+		return -ENOTSUP;
+
+	if ((LC3PLUS_HR_GET_FREQUENCY(conf) & LC3PLUS_HR_SAMPLING_FREQ_48000)
+			&& lc3plus_samplerate_supported(48000))
+		LC3PLUS_HR_SET_FREQUENCY(conf, LC3PLUS_HR_SAMPLING_FREQ_48000);
+	else if ((LC3PLUS_HR_GET_FREQUENCY(conf) & LC3PLUS_HR_SAMPLING_FREQ_96000)
+			&& lc3plus_samplerate_supported(96000))
+		LC3PLUS_HR_SET_FREQUENCY(conf, LC3PLUS_HR_SAMPLING_FREQ_96000);
+	else
+		return -ENOTSUP;
+
+	if ((conf.channels & LC3PLUS_HR_CHANNELS_2) &&
+			lc3plus_channels_supported(2))
+		conf.channels = LC3PLUS_HR_CHANNELS_2;
+	else if ((conf.channels & LC3PLUS_HR_CHANNELS_1) &&
+			lc3plus_channels_supported(1))
+		conf.channels = LC3PLUS_HR_CHANNELS_1;
+	else
+		return -ENOTSUP;
+
+	if (LC3PLUS_HR_GET_FRAME_DURATION(conf) & LC3PLUS_HR_FRAME_DURATION_10MS)
+		LC3PLUS_HR_SET_FRAME_DURATION(conf, LC3PLUS_HR_FRAME_DURATION_10MS);
+	else if (LC3PLUS_HR_GET_FRAME_DURATION(conf) & LC3PLUS_HR_FRAME_DURATION_5MS)
+		LC3PLUS_HR_SET_FRAME_DURATION(conf, LC3PLUS_HR_FRAME_DURATION_5MS);
+	else if (LC3PLUS_HR_GET_FRAME_DURATION(conf) & LC3PLUS_HR_FRAME_DURATION_2_5MS)
+		LC3PLUS_HR_SET_FRAME_DURATION(conf, LC3PLUS_HR_FRAME_DURATION_2_5MS);
+	else
+		return -ENOTSUP;
+
+	memcpy(config, &conf, sizeof(conf));
+
+	return sizeof(conf);
+}
+
+static int codec_caps_preference_cmp(const struct a2dp_codec *codec, const void *caps1, size_t caps1_size,
+		const void *caps2, size_t caps2_size, const struct a2dp_codec_audio_info *info)
+{
+	a2dp_lc3plus_hr_t conf1, conf2;
+	a2dp_lc3plus_hr_t *conf;
+	int res1, res2;
+	int a, b;
+
+	/* Order selected configurations by preference */
+	res1 = codec->select_config(codec, 0, caps1, caps1_size, info, NULL, (uint8_t *)&conf1);
+	res2 = codec->select_config(codec, 0, caps2, caps2_size, info , NULL, (uint8_t *)&conf2);
+
+#define PREFER_EXPR(expr)			\
+		do {				\
+			conf = &conf1; 		\
+			a = (expr);		\
+			conf = &conf2;		\
+			b = (expr);		\
+			if (a != b)		\
+				return b - a;	\
+		} while (0)
+
+#define PREFER_BOOL(expr)	PREFER_EXPR((expr) ? 1 : 0)
+
+	/* Prefer valid */
+	a = (res1 > 0 && (size_t)res1 == sizeof(a2dp_lc3plus_hr_t)) ? 1 : 0;
+	b = (res2 > 0 && (size_t)res2 == sizeof(a2dp_lc3plus_hr_t)) ? 1 : 0;
+	if (!a || !b)
+		return b - a;
+
+	PREFER_BOOL(conf->channels & LC3PLUS_HR_CHANNELS_2);
+	PREFER_BOOL(LC3PLUS_HR_GET_FREQUENCY(*conf) & (LC3PLUS_HR_SAMPLING_FREQ_48000 | LC3PLUS_HR_SAMPLING_FREQ_96000));
+	PREFER_BOOL(LC3PLUS_HR_GET_FREQUENCY(*conf) & LC3PLUS_HR_SAMPLING_FREQ_48000);
+
+	return 0;
+
+#undef PREFER_EXPR
+#undef PREFER_BOOL
+}
+
+static int codec_enum_config(const struct a2dp_codec *codec,
+		const void *caps, size_t caps_size, uint32_t id, uint32_t idx,
+		struct spa_pod_builder *b, struct spa_pod **param)
+{
+	a2dp_lc3plus_hr_t conf;
+	struct spa_pod_frame f2;
+	struct spa_pod_choice *choice;
+	uint32_t positionSPA_AUDIO_MAX_CHANNELS;
+	uint32_t i = 0;
+
+	if (caps_size < sizeof(conf))
+		return -EINVAL;
+
+	memcpy(&conf, caps, sizeof(conf));
+
+	if (idx > 0)
+		return 0;
+
+	spa_pod_builder_push_object(b, &f0, SPA_TYPE_OBJECT_Format, id);
+	spa_pod_builder_add(b,
+			SPA_FORMAT_mediaType,      SPA_POD_Id(SPA_MEDIA_TYPE_audio),
+			SPA_FORMAT_mediaSubtype,   SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
+			SPA_FORMAT_AUDIO_format,   SPA_POD_Id(SPA_AUDIO_FORMAT_S24_32),
+			0);
+	spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_rate, 0);
+
+	spa_pod_builder_push_choice(b, &f1, SPA_CHOICE_None, 0);
+	choice = (struct spa_pod_choice*)spa_pod_builder_frame(b, &f1);
+	i = 0;
+	if ((LC3PLUS_HR_GET_FREQUENCY(conf) & LC3PLUS_HR_SAMPLING_FREQ_96000) &&
+			lc3plus_samplerate_supported(96000)) {
+		if (i++ == 0)
+			spa_pod_builder_int(b, 96000);
+		spa_pod_builder_int(b, 96000);
+	}
+	if ((LC3PLUS_HR_GET_FREQUENCY(conf) & LC3PLUS_HR_SAMPLING_FREQ_48000) &&
+			lc3plus_samplerate_supported(48000)) {
+		if (i++ == 0)
+			spa_pod_builder_int(b, 48000);
+		spa_pod_builder_int(b, 48000);
+	}
+	if (i == 0)
+		return -EINVAL;
+	if (i > 1)
+		choice->body.type = SPA_CHOICE_Enum;
+	spa_pod_builder_pop(b, &f1);
+
+	if ((conf.channels & (LC3PLUS_HR_CHANNELS_2 | LC3PLUS_HR_CHANNELS_1)) &&
+			lc3plus_channels_supported(2) && lc3plus_channels_supported(1)) {
+		spa_pod_builder_add(b,
+				SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(2, 1, 2),
+				0);
+	} else if ((conf.channels & LC3PLUS_HR_CHANNELS_2) && lc3plus_channels_supported(2)) {
+		position0 = SPA_AUDIO_CHANNEL_FL;
+		position1 = SPA_AUDIO_CHANNEL_FR;
+		spa_pod_builder_add(b,
+				SPA_FORMAT_AUDIO_channels, SPA_POD_Int(2),
+				SPA_FORMAT_AUDIO_position, SPA_POD_Array(sizeof(uint32_t),
+					SPA_TYPE_Id, 2, position),
+				0);
+	} else if ((conf.channels & LC3PLUS_HR_CHANNELS_1) && lc3plus_channels_supported(1)) {
+		position0 = SPA_AUDIO_CHANNEL_MONO;
+		spa_pod_builder_add(b,
+				SPA_FORMAT_AUDIO_channels, SPA_POD_Int(1),
+				SPA_FORMAT_AUDIO_position, SPA_POD_Array(sizeof(uint32_t),
+					SPA_TYPE_Id, 1, position),
+				0);
+	}
+
+	*param = spa_pod_builder_pop(b, &f0);
+	return *param == NULL ? -EIO : 1;
+}
+
+static int codec_validate_config(const struct a2dp_codec *codec, uint32_t flags,
+			const void *caps, size_t caps_size,
+			struct spa_audio_info *info)
+{
+	const a2dp_lc3plus_hr_t *conf;
+
+	if (caps == NULL || caps_size < sizeof(*conf))
+		return -EINVAL;
+
+	conf = caps;
+
+	spa_zero(*info);
+	info->media_type = SPA_MEDIA_TYPE_audio;
+	info->media_subtype = SPA_MEDIA_SUBTYPE_raw;
+	info->info.raw.format = SPA_AUDIO_FORMAT_S24_32;
+
+	switch (LC3PLUS_HR_GET_FREQUENCY(*conf)) {
+	case LC3PLUS_HR_SAMPLING_FREQ_96000:
+		if (!lc3plus_samplerate_supported(96000))
+			return -EINVAL;
+		info->info.raw.rate = 96000;
+		break;
+	case LC3PLUS_HR_SAMPLING_FREQ_48000:
+		if (!lc3plus_samplerate_supported(48000))
+			return -EINVAL;
+		info->info.raw.rate = 48000;
+		break;
+	default:
+		return -EINVAL;
+        }
+
+	switch (conf->channels) {
+	case LC3PLUS_HR_CHANNELS_2:
+		if (!lc3plus_channels_supported(2))
+			return -EINVAL;
+		info->info.raw.channels = 2;
+		info->info.raw.position0 = SPA_AUDIO_CHANNEL_FL;
+		info->info.raw.position1 = SPA_AUDIO_CHANNEL_FR;
+		break;
+	case LC3PLUS_HR_CHANNELS_1:
+		if (!lc3plus_channels_supported(1))
+			return -EINVAL;
+		info->info.raw.channels = 1;
+		info->info.raw.position0 = SPA_AUDIO_CHANNEL_MONO;
+                break;
+	default:
+		return -EINVAL;
+        }
+
+	switch (LC3PLUS_HR_GET_FRAME_DURATION(*conf)) {
+	case LC3PLUS_HR_FRAME_DURATION_10MS:
+	case LC3PLUS_HR_FRAME_DURATION_5MS:
+	case LC3PLUS_HR_FRAME_DURATION_2_5MS:
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static size_t ceildiv(size_t v, size_t divisor)
+{
+	if (v % divisor == 0)
+		return v / divisor;
+	else
+		return v / divisor + 1;
+}
+
+static bool check_mtu_vs_frame_dms(struct impl *this)
+{
+	/* Only 10ms frames can be fragmented (max 0xf fragments);
+	 * others must fit in single MTU */
+	size_t header_size = sizeof(struct rtp_header) + sizeof(struct rtp_payload);
+	size_t max_fragments = (this->frame_dms == 100) ? 0xf : 1;
+	size_t payload_size = lc3plus_enc_get_num_bytes(this->enc);
+	return (size_t)this->mtu >= header_size + ceildiv(payload_size, max_fragments);
+}
+
+static void *codec_init(const struct a2dp_codec *codec, uint32_t flags,
+		void *config, size_t config_len, const struct spa_audio_info *info,
+		void *props, size_t mtu)
+{
+	a2dp_lc3plus_hr_t *conf = config;
+	struct impl *this = NULL;
+	struct spa_audio_info config_info;
+	int size;
+	int res;
+
+	if (info->media_type != SPA_MEDIA_TYPE_audio ||
+	    info->media_subtype != SPA_MEDIA_SUBTYPE_raw ||
+	    info->info.raw.format != SPA_AUDIO_FORMAT_S24_32) {
+		res = -EINVAL;
+		goto error;
+	}
+
+	if ((this = calloc(1, sizeof(struct impl))) == NULL)
+		goto error_errno;
+
+	if ((res = codec_validate_config(codec, flags, config, config_len, &config_info)) < 0)
+		goto error;
+
+	this->mtu = mtu;
+	this->samplerate = config_info.info.raw.rate;
+	this->channels = config_info.info.raw.channels;
+	this->bitrate = BITRATE_DEFAULT * this->channels;
+
+	switch (LC3PLUS_HR_GET_FRAME_DURATION(*conf)) {
+	case LC3PLUS_HR_FRAME_DURATION_10MS:
+		this->frame_dms = 100;
+		break;
+	case LC3PLUS_HR_FRAME_DURATION_5MS:
+		this->frame_dms = 50;
+		break;
+	case LC3PLUS_HR_FRAME_DURATION_2_5MS:
+		this->frame_dms = 25;
+		break;
+	default:
+		res = -EINVAL;
+		goto error;
+	}
+
+	if ((size = lc3plus_enc_get_size(this->samplerate, this->channels)) == 0) {
+		res = -EIO;
+		goto error;
+	}
+	if ((this->enc = calloc(1, size)) == NULL)
+		goto error_errno;
+	if (lc3plus_enc_init(this->enc, this->samplerate, this->channels) != LC3PLUS_OK) {
+		res = -EINVAL;
+		goto error;
+	}
+	if (lc3plus_enc_set_frame_ms(this->enc, this->frame_dms/10.0f) != LC3PLUS_OK) {
+		res = -EINVAL;
+		goto error;
+	}
+	if (lc3plus_enc_set_hrmode(this->enc, 1) != LC3PLUS_OK) {
+		res = -EINVAL;
+		goto error;
+	}
+	while (1) {
+		/* Find a valid bitrate */
+		if (lc3plus_enc_set_bitrate(this->enc, this->bitrate) != LC3PLUS_OK) {
+			res = -EINVAL;
+			goto error;
+		}
+		if (check_mtu_vs_frame_dms(this))
+			break;
+		this->bitrate = this->bitrate * 3/4;
+	}
+
+	if ((size = lc3plus_dec_get_size(this->samplerate, this->channels)) == 0) {
+		res = -EINVAL;
+		goto error;
+	}
+	if ((this->dec = calloc(1, size)) == NULL)
+		goto error_errno;
+	if (lc3plus_dec_init(this->dec, this->samplerate, this->channels, LC3PLUS_PLC_ADVANCED) != LC3PLUS_OK) {
+		res = -EINVAL;
+		goto error;
+	}
+	if (lc3plus_dec_set_frame_ms(this->dec, this->frame_dms/10.0f) != LC3PLUS_OK) {
+		res = -EINVAL;
+		goto error;
+	}
+	if (lc3plus_dec_set_hrmode(this->dec, 1) != LC3PLUS_OK) {
+		res = -EINVAL;
+		goto error;
+	}
+
+	this->e.samples = lc3plus_enc_get_input_samples(this->enc);
+	this->e.codesize = this->e.samples * this->channels * sizeof(int32_t);
+
+	spa_assert(this->e.samples <= LC3PLUS_MAX_SAMPLES);
+
+	this->e.bitrate = this->bitrate;
+	this->e.next_bitrate = this->bitrate;
+
+	return this;
+
+error_errno:
+	res = -errno;
+	goto error;
+
+error:
+	if (this && this->enc)
+		lc3plus_enc_free_memory(this->enc);
+	if (this && this->dec)
+		lc3plus_dec_free_memory(this->dec);
+	free(this);
+	errno = -res;
+	return NULL;
+}
+
+static void codec_deinit(void *data)
+{
+	struct impl *this = data;
+	lc3plus_enc_free_memory(this->enc);
+	lc3plus_dec_free_memory(this->dec);
+	free(this);
+}
+
+static int codec_get_block_size(void *data)
+{
+	struct impl *this = data;
+	return this->e.codesize;
+}
+
+static int codec_abr_process (void *data, size_t unsent)
+{
+	return -ENOTSUP;
+}
+
+static int codec_update_bitrate(struct impl *this)
+{
+	this->e.next_bitrate = SPA_CLAMP(this->e.next_bitrate,
+			BITRATE_MIN * this->channels, BITRATE_MAX * this->channels);
+
+	if (this->e.next_bitrate == this->e.bitrate)
+		return 0;
+
+	this->e.bitrate = this->e.next_bitrate;
+
+	if (lc3plus_enc_set_bitrate(this->enc, this->e.bitrate) != LC3PLUS_OK ||
+			!check_mtu_vs_frame_dms(this)) {
+		lc3plus_enc_set_bitrate(this->enc, this->bitrate);
+		return -EINVAL;
+	}
+
+	this->bitrate = this->e.bitrate;
+
+	return 0;
+}
+
+static int codec_start_encode (void *data,
+		void *dst, size_t dst_size, uint16_t seqnum, uint32_t timestamp)
+{
+	struct impl *this = data;
+	size_t header_size = sizeof(struct rtp_header) + sizeof(struct rtp_payload);
+
+	if (dst_size <= header_size)
+		return -EINVAL;
+
+	codec_update_bitrate(this);
+
+	this->e.header = (struct rtp_header *)dst;
+	this->e.payload = SPA_PTROFF(dst, sizeof(struct rtp_header), struct rtp_payload);
+	memset(dst, 0, header_size);
+
+	this->e.payload->frame_count = 0;
+	this->e.header->v = 2;
+	this->e.header->pt = 96;
+	this->e.header->sequence_number = htons(seqnum);
+	this->e.header->timestamp = htonl(timestamp);
+	this->e.header->ssrc = htonl(1);
+
+	this->e.packet_size = header_size;
+	return this->e.packet_size;
+}
+
+static void deinterleave_32_c2(int32_t * SPA_RESTRICT * SPA_RESTRICT dst, const int32_t * SPA_RESTRICT src, size_t n_samples)
+{
+	/* We'll trust the compiler to optimize this */
+	const size_t n_channels = 2;
+	size_t i, j;
+	for (j = 0; j < n_samples; ++j)
+		for (i = 0; i < n_channels; ++i)
+			dstij = *src++;
+}
+
+static void interleave_32_c2(int32_t * SPA_RESTRICT dst, const int32_t * SPA_RESTRICT * SPA_RESTRICT src, size_t n_samples)
+{
+	const size_t n_channels = 2;
+	size_t i, j;
+	for (j = 0; j < n_samples; ++j)
+		for (i = 0; i < n_channels; ++i)
+			*dst++ = srcij;
+}
+
+static int codec_encode(void *data,
+		const void *src, size_t src_size,
+		void *dst, size_t dst_size,
+		size_t *dst_out, int *need_flush)
+{
+	struct impl *this = data;
+	int frame_bytes;
+	LC3PLUS_Error res;
+	int size, processed;
+	int header_size = sizeof(struct rtp_header) + sizeof(struct rtp_payload);
+	int32_t *inputs2;
+
+	if (src == NULL) {
+		/* Produce fragment packets.
+		 *
+		 * We assume the caller gives the same buffer here as in the previous
+		 * calls to encode(), without changes in the buffer content.
+		 */
+		if (this->e.fragment == NULL ||
+				this->e.fragment_count <= 1 ||
+				this->e.fragment < dst ||
+				SPA_PTROFF(this->e.fragment, this->e.fragment_size, void) > SPA_PTROFF(dst, dst_size, void)) {
+			this->e.fragment = NULL;
+			return -EINVAL;
+		}
+
+		size = SPA_MIN(this->mtu - header_size, this->e.fragment_size);
+		memmove(dst, this->e.fragment, size);
+		*dst_out = size;
+
+		this->e.payload->is_fragmented = 1;
+		this->e.payload->frame_count = --this->e.fragment_count;
+		this->e.payload->is_last_fragment = (this->e.fragment_count == 1);
+
+		if (this->e.fragment_size > size && this->e.fragment_count > 1) {
+			this->e.fragment = SPA_PTROFF(this->e.fragment, size, void);
+			this->e.fragment_size -= size;
+			*need_flush = NEED_FLUSH_FRAGMENT;
+		} else {
+			this->e.fragment = NULL;
+			*need_flush = NEED_FLUSH_ALL;
+		}
+		return 0;
+	}
+
+	frame_bytes = lc3plus_enc_get_num_bytes(this->enc);
+	processed = 0;
+
+	if (src_size < (size_t)this->e.codesize)
+		goto done;
+	if (dst_size < (size_t)frame_bytes)
+		goto done;
+	if (this->e.payload->frame_count > 0 &&
+			this->e.packet_size + frame_bytes > this->mtu)
+		goto done;
+
+	if (this->channels == 1) {
+		inputs0 = (int32_t *)src;
+		res = lc3plus_enc24(this->enc, inputs, dst, &size);
+	} else {
+		inputs0 = this->buf0;
+		inputs1 = this->buf1;
+		deinterleave_32_c2(inputs, src, this->e.samples);
+		res = lc3plus_enc24(this->enc, inputs, dst, &size);
+	}
+	if (SPA_UNLIKELY(res != LC3PLUS_OK))
+		return -EINVAL;
+	*dst_out = size;
+
+	processed += this->e.codesize;
+	this->e.packet_size += size;
+	this->e.payload->frame_count++;
+
+done:
+	if (this->e.payload->frame_count == 0)
+		return processed;
+	if (this->e.payload->frame_count < 0xf &&
+			this->frame_dms * (this->e.payload->frame_count + 1) < 200 &&
+			this->e.packet_size + frame_bytes <= this->mtu)
+		return processed;  /* add another frame */
+
+	if (this->e.packet_size > this->mtu) {
+		/* Fragment packet */
+		spa_assert(this->e.payload->frame_count == 1);
+		spa_assert(this->frame_dms == 100);
+
+		this->e.fragment_count = ceildiv(this->e.packet_size - header_size,
+				this->mtu - header_size);
+
+		this->e.payload->is_fragmented = 1;
+		this->e.payload->is_first_fragment = 1;
+		this->e.payload->frame_count = this->e.fragment_count;
+
+		this->e.fragment_size = this->e.packet_size - this->mtu;
+		this->e.fragment = SPA_PTROFF(dst, *dst_out - this->e.fragment_size, void);
+		*need_flush = NEED_FLUSH_FRAGMENT;
+
+		/*
+		 * We keep the rest of the encoded frame in the same buffer, and rely
+		 * that the caller won't overwrite it before the next call to encode()
+		 */
+		*dst_out = SPA_PTRDIFF(this->e.fragment, dst);
+	} else {
+		*need_flush = NEED_FLUSH_ALL;
+	}
+
+	return processed;
+}
+
+static SPA_UNUSED int codec_start_decode (void *data,
+		const void *src, size_t src_size, uint16_t *seqnum, uint32_t *timestamp)
+{
+	struct impl *this = data;
+	const struct rtp_header *header = src;
+	const struct rtp_payload *payload = SPA_PTROFF(src, sizeof(struct rtp_header), void);
+	size_t header_size = sizeof(struct rtp_header) + sizeof(struct rtp_payload);
+
+	spa_return_val_if_fail (src_size > header_size, -EINVAL);
+
+	if (seqnum)
+		*seqnum = ntohs(header->sequence_number);
+	if (timestamp)
+		*timestamp = ntohl(header->timestamp);
+
+	if (payload->is_fragmented) {
+		if (payload->is_first_fragment) {
+			this->d.fragment_size = 0;
+		} else if (payload->frame_count + 1 != this->d.fragment_count ||
+				(payload->frame_count == 1 && !payload->is_last_fragment)){
+			/* Fragments not in right order: drop packet */
+			return -EINVAL;
+		}
+		this->d.fragment_count = payload->frame_count;
+		this->d.frame_size = src_size - header_size;
+	} else {
+		if (payload->frame_count <= 0)
+			return -EINVAL;
+		this->d.fragment_count = 0;
+		this->d.frame_size = (src_size - header_size) / payload->frame_count;
+		if (this->d.frame_size <= 0)
+			return -EINVAL;
+	}
+
+	return header_size;
+}
+
+static SPA_UNUSED int codec_decode(void *data,
+		const void *src, size_t src_size,
+		void *dst, size_t dst_size,
+		size_t *dst_out)
+{
+	struct impl *this = data;
+	LC3PLUS_Error res;
+	int32_t *outputs2;
+	int consumed;
+	int samples;
+
+	if (this->d.fragment_count > 0) {
+		/* Fragmented frame */
+		size_t avail;
+		avail = SPA_MIN(sizeof(this->d.fragment) - this->d.fragment_size, src_size);
+		memcpy(SPA_PTROFF(this->d.fragment, this->d.fragment_size, void), src, avail);
+
+		this->d.fragment_size += avail;
+		consumed = src_size;
+
+		if (this->d.fragment_count > 1) {
+			/* More fragments to come */
+			*dst_out = 0;
+			return consumed;
+		}
+
+		src = this->d.fragment;
+		src_size = this->d.fragment_size;
+
+		this->d.fragment_count = 0;
+		this->d.fragment_size = 0;
+	} else {
+		src_size = SPA_MIN((size_t)this->d.frame_size, src_size);
+		consumed = src_size;
+	}
+
+	samples = lc3plus_dec_get_output_samples(this->dec);
+	*dst_out = samples * this->channels * sizeof(int32_t);
+	if (dst_size < *dst_out)
+		return -EINVAL;
+
+	if (this->channels == 1) {
+		outputs0 = (int32_t *)dst;
+		res = lc3plus_dec24(this->dec, (void *)src, src_size, outputs, 0);
+	} else {
+		outputs0 = this->buf0;
+		outputs1 = this->buf1;
+		res = lc3plus_dec24(this->dec, (void *)src, src_size, outputs, 0);
+		interleave_32_c2(dst, (const int32_t**)outputs, samples);
+	}
+	if (SPA_UNLIKELY(res != LC3PLUS_OK && res != LC3PLUS_DECODE_ERROR))
+		return -EINVAL;
+
+	return consumed;
+}
+
+static int codec_reduce_bitpool(void *data)
+{
+	struct impl *this = data;
+	this->e.next_bitrate = this->bitrate * 3 / 4;
+	return 0;
+}
+
+static int codec_increase_bitpool(void *data)
+{
+	struct impl *this = data;
+	this->e.next_bitrate = this->bitrate * 5 / 4;
+	return 0;
+}
+
+const struct a2dp_codec a2dp_codec_lc3plus_hr = {
+	.id = SPA_BLUETOOTH_AUDIO_CODEC_LC3PLUS_HR,
+	.name = "lc3plus_hr",
+	.codec_id = A2DP_CODEC_VENDOR,
+	.vendor = { .vendor_id = LC3PLUS_HR_VENDOR_ID,
+		.codec_id = LC3PLUS_HR_CODEC_ID },
+	.description = "LC3plus HR",
+	.fill_caps = codec_fill_caps,
+	.select_config = codec_select_config,
+	.enum_config = codec_enum_config,
+	.validate_config = codec_validate_config,
+	.caps_preference_cmp = codec_caps_preference_cmp,
+	.init = codec_init,
+	.deinit = codec_deinit,
+	.get_block_size = codec_get_block_size,
+	.abr_process = codec_abr_process,
+	.start_encode = codec_start_encode,
+	.encode = codec_encode,
+	.start_decode = codec_start_decode,
+	.decode = codec_decode,
+	.reduce_bitpool = codec_reduce_bitpool,
+	.increase_bitpool = codec_increase_bitpool
+};
+
+A2DP_CODEC_EXPORT_DEF(
+	"lc3plus",
+	&a2dp_codec_lc3plus_hr
+);

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-codec-ldac.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codec-ldac.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-codec-sbc.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codec-sbc.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-codecs.h -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-codecs.h Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-sink.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-sink.c Changed

@@ -157,6 +157,8 @@
 	struct spa_audio_info codec_format;
 
 	int need_flush;
+	bool fragment;
+	uint64_t fragment_timeout;
 	uint32_t block_size;
 	uint8_t bufferBUFFER_SIZE;
 	uint32_t buffer_used;
@@ -436,6 +438,7 @@
 	}
 	this->need_flush = 0;
 	this->frame_count = 0;
+	this->fragment = false;
 	this->buffer_used = this->codec->start_encode(this->codec_data,
 			this->buffer, sizeof(this->buffer),
 			this->seqnum++, this->timestamp);
@@ -533,6 +536,37 @@
 	return processed;
 }
 
+static int encode_fragment(struct impl *this)
+{
+	int res;
+	size_t out_encoded;
+	struct port *port = &this->port;
+
+	spa_log_trace(this->log, "%p: encode fragment used %d, %d %d %d",
+			this, this->buffer_used, port->frame_size, this->block_size,
+			this->frame_count);
+
+	if (this->need_flush)
+		return 0;
+
+	res = this->codec->encode(this->codec_data,
+				NULL, 0,
+				this->buffer + this->buffer_used,
+				sizeof(this->buffer) - this->buffer_used,
+				&out_encoded, &this->need_flush);
+	if (res < 0)
+		return res;
+	if (res != 0)
+		return -EINVAL;
+
+	this->buffer_used += out_encoded;
+
+	spa_log_trace(this->log, "%p: processed fragment %zd used %d",
+			this, out_encoded, this->buffer_used);
+
+	return 0;
+}
+
 static int flush_buffer(struct impl *this)
 {
 	spa_log_trace(this->log, "%p: used:%d block_size:%d", this,
@@ -596,6 +630,15 @@
 	total_frames = 0;
 again:
 	written = 0;
+	if (this->fragment && !this->need_flush) {
+		int res;
+		this->fragment = false;
+		if ((res = encode_fragment(this)) < 0) {
+			/* Error */
+			reset_buffer(this);
+			return res;
+		}
+	}
 	while (!spa_list_is_empty(&port->ready) && !this->need_flush) {
 		uint8_t *src;
 		uint32_t n_bytes, n_frames;
@@ -706,6 +749,17 @@
 		uint64_t timeout = (quantum > max_excess) ?
 			(packet_time * (quantum - max_excess) / quantum) : 0;
 
+		if (this->need_flush == NEED_FLUSH_FRAGMENT) {
+			reset_buffer(this);
+			this->fragment = true;
+			this->fragment_timeout = (packet_samples > 0) ? timeout : this->fragment_timeout;
+			goto again;
+		}
+		if (this->fragment_timeout > 0) {
+			timeout = this->fragment_timeout;
+			this->fragment_timeout = 0;
+		}
+
 		reset_buffer(this);
 		if (now_time - this->last_error > SPA_NSEC_PER_SEC) {
 			if (get_transport_unused_size(this) == (int)this->fd_buffer_size) {
@@ -1406,6 +1460,11 @@
 	io = port->io;
 	spa_return_val_if_fail(io != NULL, -EIO);
 
+	if (this->position && this->position->clock.flags & SPA_IO_CLOCK_FLAG_FREEWHEEL) {
+		io->status = SPA_STATUS_NEED_DATA;
+		return SPA_STATUS_HAVE_DATA;
+	}
+
 	if (io->status == SPA_STATUS_HAVE_DATA && io->buffer_id < port->n_buffers) {
 		struct buffer *b = &port->buffersio->buffer_id;
 
@@ -1424,6 +1483,15 @@
 		io->status = SPA_STATUS_OK;
 	}
 	if (!spa_list_is_empty(&port->ready)) {
+		if (this->following) {
+			if (this->position) {
+				this->current_time = this->position->clock.nsec;
+			} else {
+				struct timespec now;
+				spa_system_clock_gettime(this->data_system, CLOCK_MONOTONIC, &now);
+				this->current_time = SPA_TIMESPEC_TO_NSEC(&now);
+			}
+		}
 		if (this->need_flush)
 			reset_buffer(this);
 		flush_data(this, this->current_time);
@@ -1477,9 +1545,43 @@
 	spa_loop_invoke(this->data_loop, do_transport_destroy, 0, NULL, 0, true, this);
 }
 
+static void transport_state_changed(void *data,
+	enum spa_bt_transport_state old,
+	enum spa_bt_transport_state state)
+{
+	struct impl *this = data;
+
+	spa_log_debug(this->log, "%p: transport %p state %d->%d", this, this->transport, old, state);
+
+	if (state < SPA_BT_TRANSPORT_STATE_ACTIVE && old == SPA_BT_TRANSPORT_STATE_ACTIVE &&
+			this->started) {
+		uint8_t buffer1024;
+		struct spa_pod_builder b = { 0 };
+
+		spa_log_debug(this->log, "%p: transport %p becomes inactive: stop and indicate error",
+				this, this->transport);
+
+		/*
+		 * If establishing connection fails due to remote end not activating
+		 * the transport, we won't get a write error, but instead see a transport
+		 * state change.
+		 *
+		 * Stop and emit a node error, to let upper levels handle it.
+		 */
+
+		do_stop(this);
+
+		spa_pod_builder_init(&b, buffer, sizeof(buffer));
+		spa_node_emit_event(&this->hooks,
+				spa_pod_builder_add_object(&b,
+						SPA_TYPE_EVENT_Node, SPA_NODE_EVENT_Error));
+	}
+}
+
 static const struct spa_bt_transport_events transport_events = {
 	SPA_VERSION_BT_TRANSPORT_EVENTS,
 	.delay_changed = transport_delay_changed,
+	.state_changed = transport_state_changed,
 	.destroy = transport_destroy,
 };

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/a2dp-source.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/a2dp-source.c Changed

@@ -154,6 +154,7 @@
 	struct spa_audio_info codec_format;
 
 	uint8_t buffer_read4096;
+	uint8_t buffer_decoded65536;
 	struct timespec now;
 	uint64_t sample_count;
 	uint64_t skip_count;
@@ -472,7 +473,6 @@
 	struct spa_data *datas;
 	struct buffer *buffer;
 	uint32_t min_data;
-	uint8_t read_decoded4096;
 
 	/* make sure the source is an input */
 	if ((source->rmask & SPA_IO_IN) == 0) {
@@ -507,10 +507,10 @@
 
 	/* decode */
 	decoded = decode_data(this, this->buffer_read, size_read,
-			read_decoded, sizeof (read_decoded));
+			this->buffer_decoded, sizeof (this->buffer_decoded));
 	if (decoded < 0) {
-		spa_log_error(this->log, "failed to decode data: %d", decoded);
-		goto stop;
+		spa_log_debug(this->log, "failed to decode data: %d", decoded);
+		return;
 	}
 	if (decoded == 0)
 		return;
@@ -557,7 +557,7 @@
 	avail = SPA_MIN(decoded, (int32_t)(datas0.maxsize - port->ready_offset));
 	if (avail < decoded)
 		spa_log_warn(this->log, "buffer too small (%d > %d)", decoded, avail);
-	memcpy ((uint8_t *)datas0.data + port->ready_offset, read_decoded, avail);
+	memcpy ((uint8_t *)datas0.data + port->ready_offset, this->buffer_decoded, avail);
 	port->ready_offset += avail;
 	this->sample_count += decoded / port->frame_size;

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/backend-native.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/backend-native.c Changed

@@ -623,15 +623,21 @@
 
 	spa_log_debug(backend->log, "key:%u value:%u", key, value);
 
-	if (key == SPA_BT_HFP_HF_IPHONEACCEV_KEY_BATTERY_LEVEL) {
+	switch (key) {
+	case SPA_BT_HFP_HF_IPHONEACCEV_KEY_BATTERY_LEVEL: {
 		// Battery level is reported in range of 0-9, convert to 10-100%
 		uint8_t level = (SPA_CLAMP(value, 0u, 9u) + 1) * 10;
 		spa_log_debug(backend->log, "battery level: %d%%", (int) level);
 
 		// TODO: report without Battery Provider (using props)
 		spa_bt_device_report_battery_level(rfcomm->device, level);
-	} else {
+		break;
+	}
+	case SPA_BT_HFP_HF_IPHONEACCEV_KEY_DOCK_STATE:
+		break;
+	default:
 		spa_log_warn(backend->log, "unknown AT+IPHONEACCEV key:%u value:%u", key, value);
+		break;
 	}
 }
 
@@ -641,7 +647,10 @@
 
 	spa_log_debug(backend->log, "indicator:%u value:%u", indicator, value);
 
-	if (indicator == SPA_BT_HFP_HF_INDICATOR_BATTERY_LEVEL) {
+	switch (indicator) {
+	case SPA_BT_HFP_HF_INDICATOR_ENHANCED_SAFETY:
+		break;
+	case SPA_BT_HFP_HF_INDICATOR_BATTERY_LEVEL:
 		// Battery level is reported in range 0-100
 		spa_log_debug(backend->log, "battery level: %u%%", value);
 
@@ -651,8 +660,10 @@
 		} else {
 			spa_log_warn(backend->log, "battery HF indicator %u outside of range 0, 100: %u", indicator, value);
 		}
-	} else {
+		break;
+	default:
 		spa_log_warn(backend->log, "unknown HF indicator:%u value:%u", indicator, value);
+		break;
 	}
 }

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/bluez5-dbus.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/bluez5-dbus.c Changed

@@ -50,6 +50,7 @@
 #include <spa/utils/string.h>
 #include <spa/utils/json.h>
 
+#include "config.h"
 #include "codec-loader.h"
 #include "player.h"
 #include "defs.h"
@@ -819,6 +820,29 @@
 	free(adapter);
 }
 
+static uint32_t adapter_connectable_profiles(struct spa_bt_adapter *adapter)
+{
+	const uint32_t profiles = adapter->profiles;
+	uint32_t mask = 0;
+
+	if (profiles & SPA_BT_PROFILE_A2DP_SINK)
+		mask |= SPA_BT_PROFILE_A2DP_SOURCE;
+	if (profiles & SPA_BT_PROFILE_A2DP_SOURCE)
+		mask |= SPA_BT_PROFILE_A2DP_SINK;
+
+	if (profiles & SPA_BT_PROFILE_HSP_AG)
+		mask |= SPA_BT_PROFILE_HSP_HS;
+	if (profiles & SPA_BT_PROFILE_HSP_HS)
+		mask |= SPA_BT_PROFILE_HSP_AG;
+
+	if (profiles & SPA_BT_PROFILE_HFP_AG)
+		mask |= SPA_BT_PROFILE_HFP_HF;
+	if (profiles & SPA_BT_PROFILE_HFP_HF)
+		mask |= SPA_BT_PROFILE_HFP_AG;
+
+	return mask;
+}
+
 struct spa_bt_device *spa_bt_device_find(struct spa_bt_monitor *monitor, const char *path)
 {
 	struct spa_bt_device *d;
@@ -1144,6 +1168,10 @@
 		}
 	}
 
+	/* Connect only profiles the adapter has a counterpart for */
+	if (device->adapter)
+		reconnect &= adapter_connectable_profiles(device->adapter);
+
 	if (!(device->connected_profiles & SPA_BT_PROFILE_HEADSET_HEAD_UNIT)) {
 		if (reconnect & SPA_BT_PROFILE_HFP_HF) {
 			SPA_FLAG_CLEAR(reconnect, SPA_BT_PROFILE_HSP_HS);
@@ -1257,9 +1285,12 @@
 {
 	struct spa_bt_monitor *monitor = device->monitor;
 	uint32_t connected_profiles = device->connected_profiles;
-	uint32_t direction_masks2 = {
-		SPA_BT_PROFILE_A2DP_SINK | SPA_BT_PROFILE_HEADSET_AUDIO,
-		SPA_BT_PROFILE_A2DP_SOURCE | SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY,
+	uint32_t connectable_profiles =
+		device->adapter ? adapter_connectable_profiles(device->adapter) : 0;
+	uint32_t direction_masks3 = {
+		SPA_BT_PROFILE_A2DP_SINK | SPA_BT_PROFILE_HEADSET_HEAD_UNIT,
+		SPA_BT_PROFILE_A2DP_SOURCE,
+		SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY,
 	};
 	bool direction_connected = false;
 	bool all_connected;
@@ -1271,15 +1302,16 @@
 		connected_profiles |= SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY;
 
 	for (i = 0; i < SPA_N_ELEMENTS(direction_masks); ++i) {
-		uint32_t mask = direction_masksi & device->profiles;
+		uint32_t mask = direction_masksi & device->profiles & connectable_profiles;
 		if (mask && (connected_profiles & mask) == mask)
 			direction_connected = true;
 	}
 
 	all_connected = (device->profiles & connected_profiles) == device->profiles;
 
-	spa_log_debug(monitor->log, "device %p: profiles %08x %08x %d",
-			device, device->profiles, connected_profiles, device->added);
+	spa_log_debug(monitor->log, "device %p: profiles %08x %08x connectable:%08x added:%d all:%d dir:%d",
+			device, device->profiles, connected_profiles, connectable_profiles,
+			device->added, all_connected, direction_connected);
 
 	if (connected_profiles == 0 && spa_list_is_empty(&device->codec_switch_list)) {
 		device_stop_timer(device);
@@ -1579,7 +1611,11 @@
 		if (j >= size) {
 			const struct a2dp_codec **p;
 			size = size * 2;
+#ifdef HAVE_REALLOCARRRAY
 			p = reallocarray(supported_codecs, size, sizeof(const struct a2dp_codec *));
+#else
+			p = realloc(supported_codecs, size * sizeof(const struct a2dp_codec *));
+#endif
 			if (p == NULL) {
 				free(supported_codecs);
 				return NULL;
@@ -1862,6 +1898,7 @@
 	if (device && device->connected_profiles != prev_connected)
 		spa_bt_device_emit_profiles_changed(device, device->profiles, prev_connected);
 
+	free(transport->endpoint_path);
 	free(transport->path);
 	free(transport);
 }
@@ -2525,6 +2562,7 @@
 static bool a2dp_codec_switch_process_current(struct spa_bt_a2dp_codec_switch *sw)
 {
 	struct spa_bt_remote_endpoint *ep;
+	struct spa_bt_transport *t;
 	const struct a2dp_codec *codec;
 	uint8_t configA2DP_MAX_CAPS_SIZE;
 	char *local_endpoint_base;
@@ -2579,6 +2617,19 @@
 		goto next;
 	}
 
+	/* Each endpoint can be used by only one device at a time (on each adapter) */
+	spa_list_for_each(t, &sw->device->monitor->transport_list, link) {
+		if (t->device == sw->device)
+			continue;
+		if (t->device->adapter != sw->device->adapter)
+			continue;
+		if (spa_streq(t->endpoint_path, local_endpoint)) {
+			spa_log_debug(sw->device->monitor->log, "a2dp codec switch %p: endpoint %s in use, try next",
+					sw, local_endpoint);
+			goto next;
+		}
+	}
+
 	res = codec->select_config(codec, 0, ep->capabilities, ep->capabilities_len,
 				   &sw->device->monitor->default_audio_info,
 				   sw->device->settings, config);
@@ -3026,6 +3077,8 @@
 		transport->volumesi.hw_volume_max = SPA_BT_VOLUME_A2DP_MAX;
 	}
 
+	free(transport->endpoint_path);
+	transport->endpoint_path = strdup(endpoint);
 	transport->profile = profile;
 	transport->a2dp_codec = codec;
 	transport_update_props(transport, &it1, NULL);
@@ -3531,8 +3584,10 @@
 		if (!is_a2dp_codec_enabled(monitor, codec))
 			continue;
 
-		register_a2dp_endpoint(monitor, codec, A2DP_SOURCE_ENDPOINT);
-		register_a2dp_endpoint(monitor, codec, A2DP_SINK_ENDPOINT);
+		if (codec->encode != NULL)
+			register_a2dp_endpoint(monitor, codec, A2DP_SOURCE_ENDPOINT);
+		if (codec->decode != NULL)
+			register_a2dp_endpoint(monitor, codec, A2DP_SINK_ENDPOINT);
 	}
 
 	return 0;
@@ -4517,7 +4572,7 @@
 		if ((str = spa_dict_lookup(info, "bluez5.dummy-avrcp-player")) != NULL)
 			this->dummy_avrcp_player = spa_atob(str);
 		else
-			this->dummy_avrcp_player = true;
+			this->dummy_avrcp_player = false;
 	}
 
 	register_media_application(this);

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/codec-loader.c -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/codec-loader.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/defs.h -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/defs.h Changed

pipewire-0.3.51.tar.gz/spa/plugins/bluez5/meson.build -> pipewire-0.3.52.tar.gz/spa/plugins/bluez5/meson.build Changed

pipewire-0.3.51.tar.gz/spa/plugins/libcamera/libcamera-device.cpp -> pipewire-0.3.52.tar.gz/spa/plugins/libcamera/libcamera-device.cpp Changed

@@ -78,37 +78,37 @@
 	std::shared_ptr<Camera> camera;
 };
 
-std::string cameraDesc(const Camera *camera)
+std::string cameraModel(const Camera *camera)
 {
 	const ControlList &props = camera->properties();
-	bool addModel = true;
 	std::string name;
+	if (props.contains(properties::Model))
+		name = props.get(properties::Model);
+	else
+		name = camera->id();
+        return name;
+}
 
-        if (props.contains(properties::Location)) {
+std::string cameraLoc(const Camera *camera)
+{
+	const ControlList &props = camera->properties();
+	std::string location;
+	if (props.contains(properties::Location)) {
 		switch (props.get(properties::Location)) {
 		case properties::CameraLocationFront:
-			addModel = false;
-			name = "Internal front camera ";
-		break;
+			location = "front";
+			break;
 		case properties::CameraLocationBack:
-			addModel = false;
-			name = "Internal back camera ";
-		break;
+			location = "back";
+			break;
 		case properties::CameraLocationExternal:
-			name = "External camera ";
+			location = "external";
 			break;
 		}
 	}
-	if (addModel) {
-		if (props.contains(properties::Model))
-			name = "" + props.get(properties::Model);
-		else
-			name = "" + camera->id();
-	}
-        return name;
+	return location;
 }
 
-
 static int emit_info(struct impl *impl, bool full)
 {
 	struct spa_dict_item items10;
@@ -116,7 +116,7 @@
 	uint32_t n_items = 0;
 	struct spa_device_info info;
 	struct spa_param_info params2;
-	char path256, desc256, name256;
+	char path256, location10, model256, name256;
 
 	info = SPA_DEVICE_INFO_INIT();
 
@@ -128,8 +128,11 @@
 	ADD_ITEM(SPA_KEY_DEVICE_API, "libcamera");
 	ADD_ITEM(SPA_KEY_MEDIA_CLASS, "Video/Device");
 	ADD_ITEM(SPA_KEY_API_LIBCAMERA_PATH, (char *)impl->props.device);
-	snprintf(desc, sizeof(desc), "%s", cameraDesc(impl->camera.get()).c_str());
-	ADD_ITEM(SPA_KEY_DEVICE_DESCRIPTION, desc);
+	snprintf(location, sizeof(location), "%s", cameraLoc(impl->camera.get()).c_str());
+	ADD_ITEM(SPA_KEY_API_LIBCAMERA_LOCATION, location);
+	snprintf(model, sizeof(model), "%s", cameraModel(impl->camera.get()).c_str());
+	ADD_ITEM(SPA_KEY_DEVICE_PRODUCT_NAME, model);
+	ADD_ITEM(SPA_KEY_DEVICE_DESCRIPTION, model);
 	snprintf(name, sizeof(name), "libcamera_device.%s", impl->props.device);
 	ADD_ITEM(SPA_KEY_DEVICE_NAME, name);
 #undef ADD_ITEM

pipewire-0.3.51.tar.gz/spa/plugins/libcamera/libcamera-utils.cpp -> pipewire-0.3.52.tar.gz/spa/plugins/libcamera/libcamera-utils.cpp Changed

pipewire-0.3.51.tar.gz/spa/plugins/support/loop.c -> pipewire-0.3.52.tar.gz/spa/plugins/support/loop.c Changed

@@ -370,6 +370,24 @@
 	spa_list_init(&impl->destroy_list);
 }
 
+struct cancellation_handler_data {
+	struct spa_poll_event *ep;
+	int ep_count;
+};
+
+static void cancellation_handler(void *closure)
+{
+	const struct cancellation_handler_data *data = closure;
+
+	for (int i = 0; i < data->ep_count; i++) {
+		struct spa_source *s = data->epi.data;
+		if (SPA_LIKELY(s)) {
+			s->rmask = 0;
+			s->priv = NULL;
+		}
+	}
+}
+
 static int loop_iterate(void *object, int timeout)
 {
 	struct impl *impl = object;
@@ -384,6 +402,9 @@
 	spa_loop_control_hook_after(&impl->hooks_list);
 	impl->polling = false;
 
+	struct cancellation_handler_data cdata = { ep, nfds };
+	pthread_cleanup_push(cancellation_handler, &cdata);
+
 	/* first we set all the rmasks, then call the callbacks. The reason is that
 	 * some callback might also want to look at other sources it manages and
 	 * can then reset the rmask to suppress the callback */
@@ -409,13 +430,7 @@
 			s->func(s);
 	}
 
-	for (i = 0; i < nfds; i++) {
-		struct spa_source *s = epi.data;
-		if (SPA_LIKELY(s)) {
-			s->rmask = 0;
-			s->priv = NULL;
-		}
-	}
+	pthread_cleanup_pop(true);
 
 	return nfds;
 }

pipewire-0.3.51.tar.gz/spa/plugins/test/fakesink.c -> pipewire-0.3.52.tar.gz/spa/plugins/test/fakesink.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/test/fakesrc.c -> pipewire-0.3.52.tar.gz/spa/plugins/test/fakesrc.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/v4l2/v4l2-utils.c -> pipewire-0.3.52.tar.gz/spa/plugins/v4l2/v4l2-utils.c Changed

@@ -1156,17 +1156,17 @@
 			SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo,
 			SPA_PROP_INFO_id,   SPA_POD_Id(prop_id),
 			SPA_PROP_INFO_type, SPA_POD_CHOICE_STEP_Int(
-							queryctrl.default_value,
-							queryctrl.minimum,
-							queryctrl.maximum,
-							queryctrl.step),
+							(int32_t)queryctrl.default_value,
+							(int32_t)queryctrl.minimum,
+							(int32_t)queryctrl.maximum,
+							(int32_t)queryctrl.step),
 			SPA_PROP_INFO_description, SPA_POD_String(queryctrl.name));
 		break;
 	case V4L2_CTRL_TYPE_BOOLEAN:
 		param = spa_pod_builder_add_object(&b,
 			SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo,
 			SPA_PROP_INFO_id,   SPA_POD_Id(prop_id),
-			SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool(queryctrl.default_value),
+			SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool((bool)queryctrl.default_value),
 			SPA_PROP_INFO_description, SPA_POD_String(queryctrl.name));
 		break;
 	case V4L2_CTRL_TYPE_MENU:
@@ -1177,7 +1177,7 @@
 		spa_pod_builder_push_object(&b, &f0, SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo);
 		spa_pod_builder_add(&b,
 			SPA_PROP_INFO_id,    SPA_POD_Id(prop_id),
-			SPA_PROP_INFO_type,  SPA_POD_CHOICE_ENUM_Int(1, queryctrl.default_value),
+			SPA_PROP_INFO_type,  SPA_POD_CHOICE_ENUM_Int(1, (int32_t)queryctrl.default_value),
 			SPA_PROP_INFO_description,  SPA_POD_String(queryctrl.name),
 			0);

pipewire-0.3.51.tar.gz/spa/plugins/videotestsrc/videotestsrc.c -> pipewire-0.3.52.tar.gz/spa/plugins/videotestsrc/videotestsrc.c Changed

pipewire-0.3.51.tar.gz/spa/plugins/vulkan/meson.build -> pipewire-0.3.52.tar.gz/spa/plugins/vulkan/meson.build Changed

pipewire-0.3.51.tar.gz/spa/plugins/vulkan/plugin.c -> pipewire-0.3.52.tar.gz/spa/plugins/vulkan/plugin.c Changed

pipewire-0.3.52.tar.gz/spa/plugins/vulkan/shaders/filter-color.comp Added

pipewire-0.3.52.tar.gz/spa/plugins/vulkan/shaders/filter.comp Added

@@ -0,0 +1,44 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+#define WORKGROUP_SIZE 32
+layout (local_size_x = WORKGROUP_SIZE, local_size_y = WORKGROUP_SIZE, local_size_z = 1 ) in;
+
+layout(rgba32f, set = 0, binding = 0) uniform image2D resultImage;
+layout(set = 0, binding = 1) uniform sampler2D iChannel0;
+
+layout( push_constant ) uniform Constants {
+  float time;
+  int frame;
+  int width;
+  int height;
+} PushConstant;
+
+float iTime;
+int iFrame;
+vec3 iResolution;
+vec4 iMouse;
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord );
+
+void main()
+{
+	iTime = PushConstant.time;
+	iFrame = PushConstant.frame;
+	iResolution = vec3(float(PushConstant.width), float(PushConstant.height), 0.0);
+	iMouse = vec4(0.0, 0.0, 0.0, 0.0);
+	vec2 coord = vec2(float(gl_GlobalInvocationID.x),
+			iResolution.y - float(gl_GlobalInvocationID.y));
+	vec4 outColor;
+
+	if(coord.x >= iResolution.x || coord.y >= iResolution.y)
+		return;
+
+	mainImage(outColor, coord);
+
+	imageStore(resultImage, ivec2(gl_GlobalInvocationID.xy), outColor);
+}
+
+//#include "smearcam.comp"
+#include "filter-color.comp"
+//#include "filter-ripple.comp"

pipewire-0.3.52.tar.gz/spa/plugins/vulkan/shaders/filter.spv Added

pipewire-0.3.51.tar.gz/spa/plugins/vulkan/shaders/main.comp -> pipewire-0.3.52.tar.gz/spa/plugins/vulkan/shaders/main.comp Changed

pipewire-0.3.51.tar.gz/spa/plugins/vulkan/shaders/main.spv -> pipewire-0.3.52.tar.gz/spa/plugins/vulkan/shaders/main.spv Changed

pipewire-0.3.52.tar.gz/spa/plugins/vulkan/vulkan-compute-filter.c Added

@@ -0,0 +1,806 @@
+/* Spa
+ *
+ * Copyright © 2019 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 <errno.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <spa/support/plugin.h>
+#include <spa/support/log.h>
+#include <spa/support/loop.h>
+#include <spa/utils/list.h>
+#include <spa/utils/keys.h>
+#include <spa/utils/names.h>
+#include <spa/utils/string.h>
+#include <spa/node/node.h>
+#include <spa/node/utils.h>
+#include <spa/node/io.h>
+#include <spa/node/keys.h>
+#include <spa/param/video/format-utils.h>
+#include <spa/param/param.h>
+#include <spa/pod/filter.h>
+
+#include "vulkan-utils.h"
+
+#define NAME "vulkan-compute-filter"
+
+struct buffer {
+	uint32_t id;
+#define BUFFER_FLAG_OUT (1<<0)
+	uint32_t flags;
+	struct spa_buffer *outbuf;
+	struct spa_meta_header *h;
+	struct spa_list link;
+};
+
+struct port {
+	uint64_t info_all;
+	struct spa_port_info info;
+
+	enum spa_direction direction;
+	struct spa_param_info params5;
+
+	struct spa_io_buffers *io;
+
+	bool have_format;
+	struct spa_video_info current_format;
+
+	struct buffer buffersMAX_BUFFERS;
+	uint32_t n_buffers;
+
+	struct spa_list empty;
+	struct spa_list ready;
+	uint32_t stream_id;
+};
+
+struct impl {
+	struct spa_handle handle;
+	struct spa_node node;
+
+	struct spa_log *log;
+
+	struct spa_io_position *position;
+
+	uint64_t info_all;
+	struct spa_node_info info;
+	struct spa_param_info params2;
+
+	struct spa_hook_list hooks;
+	struct spa_callbacks callbacks;
+
+	bool started;
+
+	struct vulkan_state state;
+	struct port port2;
+};
+
+#define CHECK_PORT(this,d,p)  ((p) < 1)
+
+static int impl_node_enum_params(void *object, int seq,
+				 uint32_t id, uint32_t start, uint32_t num,
+				 const struct spa_pod *filter)
+{
+	struct impl *this = object;
+	struct spa_pod *param;
+	struct spa_pod_builder b = { 0 };
+	uint8_t buffer1024;
+	struct spa_result_node_params result;
+	uint32_t count = 0;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+	spa_return_val_if_fail(num != 0, -EINVAL);
+
+	result.id = id;
+	result.next = start;
+      next:
+	result.index = result.next++;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+
+	switch (id) {
+	default:
+		return -ENOENT;
+	}
+
+	if (spa_pod_filter(&b, &result.param, param, filter) < 0)
+		goto next;
+
+	spa_node_emit_result(&this->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result);
+
+	if (++count != num)
+		goto next;
+
+	return 0;
+}
+
+static int impl_node_set_io(void *object, uint32_t id, void *data, size_t size)
+{
+	struct impl *this = object;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+
+	switch (id) {
+	case SPA_IO_Position:
+		if (size > 0 && size < sizeof(struct spa_io_position))
+			return -EINVAL;
+		this->position = data;
+		break;
+	default:
+		return -ENOENT;
+	}
+	return 0;
+}
+static int impl_node_set_param(void *object, uint32_t id, uint32_t flags,
+			       const struct spa_pod *param)
+{
+	struct impl *this = object;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+
+	switch (id) {
+	default:
+		return -ENOENT;
+	}
+	return 0;
+}
+
+static inline void reuse_buffer(struct impl *this, struct port *port, uint32_t id)
+{
+	struct buffer *b = &port->buffersid;
+
+	if (SPA_FLAG_IS_SET(b->flags, BUFFER_FLAG_OUT)) {
+		spa_log_debug(this->log, NAME " %p: reuse buffer %d", this, id);
+
+		SPA_FLAG_CLEAR(b->flags, BUFFER_FLAG_OUT);
+		spa_list_append(&port->empty, &b->link);
+	}
+}
+
+static int impl_node_send_command(void *object, const struct spa_command *command)
+{
+	struct impl *this = object;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+	spa_return_val_if_fail(command != NULL, -EINVAL);
+
+	switch (SPA_NODE_COMMAND_ID(command)) {
+	case SPA_NODE_COMMAND_Start:
+		if (this->started)
+			return 0;
+
+		this->started = true;
+		spa_vulkan_start(&this->state);
+		break;
+
+	case SPA_NODE_COMMAND_Suspend:
+	case SPA_NODE_COMMAND_Pause:
+		if (!this->started)
+			return 0;
+
+		this->started = false;
+		spa_vulkan_stop(&this->state);
+		break;
+	default:
+		return -ENOTSUP;
+	}
+	return 0;
+}
+
+static const struct spa_dict_item node_info_items = {
+	{ SPA_KEY_MEDIA_CLASS, "Video/Filter" },
+};
+
+static void emit_node_info(struct impl *this, bool full)
+{
+	uint64_t old = full ? this->info.change_mask : 0;
+	if (full)
+		this->info.change_mask = this->info_all;
+	if (this->info.change_mask) {
+		this->info.props = &SPA_DICT_INIT_ARRAY(node_info_items);
+		spa_node_emit_info(&this->hooks, &this->info);
+		this->info.change_mask = old;
+	}
+}
+
+static void emit_port_info(struct impl *this, struct port *port, bool full)
+{
+	uint64_t old = full ? port->info.change_mask : 0;
+	if (full)
+		port->info.change_mask = port->info_all;
+	if (port->info.change_mask) {
+		struct spa_dict_item items1;
+
+		items0 = SPA_DICT_ITEM_INIT(SPA_KEY_FORMAT_DSP, "32 bit float RGBA video");
+		port->info.props = &SPA_DICT_INIT(items, 1);
+		spa_node_emit_port_info(&this->hooks,
+				port->direction, 0, &port->info);
+		port->info.change_mask = old;
+	}
+}
+
+static int
+impl_node_add_listener(void *object,
+		struct spa_hook *listener,
+		const struct spa_node_events *events,
+		void *data)
+{
+	struct impl *this = object;
+	struct spa_hook_list save;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+
+	spa_hook_list_isolate(&this->hooks, &save, listener, events, data);
+
+	emit_node_info(this, true);
+	emit_port_info(this, &this->port0, true);
+	emit_port_info(this, &this->port1, true);
+
+	spa_hook_list_join(&this->hooks, &save);
+
+	return 0;
+}
+
+static int
+impl_node_set_callbacks(void *object,
+			const struct spa_node_callbacks *callbacks,
+			void *data)
+{
+	struct impl *this = object;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+
+	this->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
+
+	return 0;
+}
+
+static int impl_node_add_port(void *object, enum spa_direction direction, uint32_t port_id,
+		const struct spa_dict *props)
+{
+	return -ENOTSUP;
+}
+
+static int
+impl_node_remove_port(void *object, enum spa_direction direction, uint32_t port_id)
+{
+	return -ENOTSUP;
+}
+
+static int port_enum_formats(void *object,
+			     enum spa_direction direction, uint32_t port_id,
+			     uint32_t index,
+			     const struct spa_pod *filter,
+			     struct spa_pod **param,
+			     struct spa_pod_builder *builder)
+{
+	switch (index) {
+	case 0:
+		*param = spa_pod_builder_add_object(builder,
+			SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
+			SPA_FORMAT_mediaType,       SPA_POD_Id(SPA_MEDIA_TYPE_video),
+			SPA_FORMAT_mediaSubtype,    SPA_POD_Id(SPA_MEDIA_SUBTYPE_dsp),
+			SPA_FORMAT_VIDEO_format,    SPA_POD_Id(SPA_VIDEO_FORMAT_DSP_F32));
+		break;
+	default:
+		return 0;
+	}
+	return 1;
+}
+
+static int
+impl_node_port_enum_params(void *object, int seq,
+			enum spa_direction direction, uint32_t port_id,
+			uint32_t id, uint32_t start, uint32_t num,
+			const struct spa_pod *filter)
+{
+	struct impl *this = object;
+	struct port *port;
+	struct spa_pod_builder b = { 0 };
+	uint8_t buffer1024;
+	struct spa_pod *param;
+	struct spa_result_node_params result;
+	uint32_t count = 0;
+	int res;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+	spa_return_val_if_fail(num != 0, -EINVAL);
+
+	spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
+	port = &this->portdirection;
+
+	result.id = id;
+	result.next = start;
+      next:
+	result.index = result.next++;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+
+	switch (id) {
+	case SPA_PARAM_EnumFormat:
+		if ((res = port_enum_formats(this, direction, port_id,
+						result.index, filter, &param, &b)) <= 0)
+			return res;
+		break;
+
+	case SPA_PARAM_Format:
+		if (!port->have_format)
+			return -EIO;
+		if (result.index > 0)
+			return 0;
+
+		param = spa_format_video_dsp_build(&b, id, &port->current_format.info.dsp);
+		break;
+
+	case SPA_PARAM_Buffers:
+	{
+		if (!port->have_format)
+			return -EIO;
+		if (this->position == NULL)
+			return -EIO;
+		if (result.index > 0)
+			return 0;
+
+		spa_log_debug(this->log, NAME" %p: %dx%d stride %d", this,
+				this->position->video.size.width,
+				this->position->video.size.height,
+				this->position->video.stride);
+
+		param = spa_pod_builder_add_object(&b,
+			SPA_TYPE_OBJECT_ParamBuffers, id,
+			SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
+			SPA_PARAM_BUFFERS_blocks,  SPA_POD_Int(1),
+			SPA_PARAM_BUFFERS_size,    SPA_POD_Int(this->position->video.stride *
+								this->position->video.size.height),
+			SPA_PARAM_BUFFERS_stride,  SPA_POD_Int(this->position->video.stride));
+		break;
+	}
+	case SPA_PARAM_Meta:
+		switch (result.index) {
+		case 0:
+			param = spa_pod_builder_add_object(&b,
+				SPA_TYPE_OBJECT_ParamMeta, id,
+				SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
+				SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
+			break;
+
+		default:
+			return 0;
+		}
+		break;
+	default:
+		return -ENOENT;
+	}
+
+	if (spa_pod_filter(&b, &result.param, param, filter) < 0)
+		goto next;
+
+	spa_node_emit_result(&this->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result);
+
+	if (++count != num)
+		goto next;
+
+	return 0;
+}
+
+static int clear_buffers(struct impl *this, struct port *port)
+{
+	if (port->n_buffers > 0) {
+		spa_log_debug(this->log, NAME " %p: clear buffers", this);
+		spa_vulkan_stop(&this->state);
+		spa_vulkan_use_buffers(&this->state, &this->state.streamsport->stream_id, 0, 0, NULL);
+		port->n_buffers = 0;
+		spa_list_init(&port->empty);
+		spa_list_init(&port->ready);
+		this->started = false;
+	}
+	return 0;
+}
+
+static int port_set_format(struct impl *this, struct port *port,
+			   uint32_t flags,
+			   const struct spa_pod *format)
+{
+	int res;
+
+	if (format == NULL) {
+		port->have_format = false;
+		clear_buffers(this, port);
+		spa_vulkan_unprepare(&this->state);
+	} else {
+		struct spa_video_info info = { 0 };
+
+		if ((res = spa_format_parse(format, &info.media_type, &info.media_subtype)) < 0)
+			return res;
+
+		if (info.media_type != SPA_MEDIA_TYPE_video &&
+		    info.media_subtype != SPA_MEDIA_SUBTYPE_dsp)
+			return -EINVAL;
+
+		if (spa_format_video_dsp_parse(format, &info.info.dsp) < 0)
+			return -EINVAL;
+
+		if (info.info.dsp.format != SPA_VIDEO_FORMAT_DSP_F32)
+			return -EINVAL;
+
+		this->state.constants.width = this->position->video.size.width;
+		this->state.constants.height = this->position->video.size.height;
+
+		port->current_format = info;
+		port->have_format = true;
+	}
+
+	port->info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
+	if (port->have_format) {
+		port->params3 = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_READWRITE);
+		port->params4 = SPA_PARAM_INFO(SPA_PARAM_Buffers, SPA_PARAM_INFO_READ);
+	} else {
+		port->params3 = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
+		port->params4 = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
+	}
+	emit_port_info(this, port, false);
+
+	return 0;
+}
+
+static int
+impl_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 impl *this = object;
+	struct port *port;
+	int res;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+	spa_return_val_if_fail(CHECK_PORT(node, direction, port_id), -EINVAL);
+	port = &this->portdirection;
+
+	switch (id) {
+	case SPA_PARAM_Format:
+		res = port_set_format(this, port, flags, param);
+		break;
+	default:
+		return -ENOENT;
+	}
+	return res;
+}
+
+static int
+impl_node_port_use_buffers(void *object,
+			   enum spa_direction direction,
+			   uint32_t port_id,
+			   uint32_t flags,
+			   struct spa_buffer **buffers,
+			   uint32_t n_buffers)
+{
+	struct impl *this = object;
+	struct port *port;
+	uint32_t i;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+	spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
+	port = &this->portdirection;
+
+	if (!port->have_format)
+		return -EIO;
+
+	clear_buffers(this, port);
+
+	for (i = 0; i < n_buffers; i++) {
+		struct buffer *b;
+
+		b = &port->buffersi;
+		b->id = i;
+		b->outbuf = buffersi;
+		b->flags = 0;
+		b->h = spa_buffer_find_meta_data(buffersi, SPA_META_Header, sizeof(*b->h));
+
+		spa_log_info(this->log, "%p: %d:%d add buffer %p", port, direction, port_id, b);
+		spa_list_append(&port->empty, &b->link);
+	}
+	spa_vulkan_use_buffers(&this->state, &this->state.streamsport->stream_id, flags, n_buffers, buffers);
+	port->n_buffers = n_buffers;
+
+	return 0;
+}
+
+static int
+impl_node_port_set_io(void *object,
+		      enum spa_direction direction,
+		      uint32_t port_id,
+		      uint32_t id,
+		      void *data, size_t size)
+{
+	struct impl *this = object;
+	struct port *port;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+	spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
+	port = &this->portdirection;
+
+	switch (id) {
+	case SPA_IO_Buffers:
+		port->io = data;
+		break;
+	default:
+		return -ENOENT;
+	}
+	return 0;
+}
+
+static int impl_node_port_reuse_buffer(void *object, uint32_t port_id, uint32_t buffer_id)
+{
+	struct impl *this = object;
+	struct port *port;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+	spa_return_val_if_fail(port_id == 0, -EINVAL);
+
+	port = &this->portSPA_DIRECTION_OUTPUT;
+	spa_return_val_if_fail(buffer_id < port->n_buffers, -EINVAL);
+
+	reuse_buffer(this, port, buffer_id);
+
+	return 0;
+}
+
+static int impl_node_process(void *object)
+{
+	struct impl *this = object;
+	struct port *inport, *outport;
+	struct spa_io_buffers *inio, *outio;
+	struct buffer *b;
+
+	spa_return_val_if_fail(this != NULL, -EINVAL);
+
+	inport = &this->portSPA_DIRECTION_INPUT;
+	inio = inport->io;
+	spa_return_val_if_fail(inio != NULL, -EIO);
+
+	if (inio->status != SPA_STATUS_HAVE_DATA)
+		return inio->status;
+
+	if (inio->buffer_id >= inport->n_buffers) {
+		inio->status = -EINVAL;
+		return -EINVAL;
+	}
+
+	outport = &this->portSPA_DIRECTION_OUTPUT;
+	outio = outport->io;
+	spa_return_val_if_fail(outio != NULL, -EIO);
+
+	if (outio->status == SPA_STATUS_HAVE_DATA)
+		return SPA_STATUS_HAVE_DATA;
+
+	if (outio->buffer_id < outport->n_buffers) {
+		reuse_buffer(this, outport, outio->buffer_id);
+		outio->buffer_id = SPA_ID_INVALID;
+	}
+
+	if (spa_list_is_empty(&outport->empty)) {
+		spa_log_debug(this->log, NAME " %p: out of buffers", this);
+		return -EPIPE;
+	}
+	b = &inport->buffersinio->buffer_id;
+	this->state.streamsinport->stream_id.pending_buffer_id = b->id;
+	inio->status = SPA_STATUS_NEED_DATA;
+
+	b = spa_list_first(&outport->empty, struct buffer, link);
+	spa_list_remove(&b->link);
+	SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT);
+	this->state.streamsoutport->stream_id.pending_buffer_id = b->id;
+
+	this->state.constants.time += 0.025;
+	this->state.constants.frame++;
+
+	spa_log_debug(this->log, "filter into %d", b->id);
+
+	spa_vulkan_process(&this->state);
+
+	b->outbuf->datas0.chunk->offset = 0;
+	b->outbuf->datas0.chunk->size = b->outbuf->datas0.maxsize;
+	b->outbuf->datas0.chunk->stride = this->position->video.stride;
+
+	outio->buffer_id = b->id;
+	outio->status = SPA_STATUS_HAVE_DATA;
+
+	return SPA_STATUS_NEED_DATA | SPA_STATUS_HAVE_DATA;
+}
+
+static const struct spa_node_methods impl_node = {
+	SPA_VERSION_NODE_METHODS,
+	.add_listener = impl_node_add_listener,
+	.set_callbacks = impl_node_set_callbacks,
+	.enum_params = impl_node_enum_params,
+	.set_param = impl_node_set_param,
+	.set_io = impl_node_set_io,
+	.send_command = impl_node_send_command,
+	.add_port = impl_node_add_port,
+	.remove_port = impl_node_remove_port,
+	.port_enum_params = impl_node_port_enum_params,
+	.port_set_param = impl_node_port_set_param,
+	.port_use_buffers = impl_node_port_use_buffers,
+	.port_set_io = impl_node_port_set_io,
+	.port_reuse_buffer = impl_node_port_reuse_buffer,
+	.process = impl_node_process,
+};
+
+static int impl_get_interface(struct spa_handle *handle, const char *type, void **interface)
+{
+	struct impl *this;
+
+	spa_return_val_if_fail(handle != NULL, -EINVAL);
+	spa_return_val_if_fail(interface != NULL, -EINVAL);
+
+	this = (struct impl *) handle;
+
+	if (spa_streq(type, SPA_TYPE_INTERFACE_Node))
+		*interface = &this->node;
+	else
+		return -ENOENT;
+
+	return 0;
+}
+
+static int impl_clear(struct spa_handle *handle)
+{
+	return 0;
+}
+
+static size_t
+impl_get_size(const struct spa_handle_factory *factory,
+	      const struct spa_dict *params)
+{
+	return sizeof(struct impl);
+}
+
+static int
+impl_init(const struct spa_handle_factory *factory,
+	  struct spa_handle *handle,
+	  const struct spa_dict *info,
+	  const struct spa_support *support,
+	  uint32_t n_support)
+{
+	struct impl *this;
+	struct port *port;
+
+	spa_return_val_if_fail(factory != NULL, -EINVAL);
+	spa_return_val_if_fail(handle != NULL, -EINVAL);
+
+	handle->get_interface = impl_get_interface;
+	handle->clear = impl_clear;
+
+	this = (struct impl *) handle;
+
+	this->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log);
+	this->state.log = this->log;
+	this->state.shaderName = "spa/plugins/vulkan/shaders/filter.spv";
+
+	spa_hook_list_init(&this->hooks);
+
+	this->node.iface = SPA_INTERFACE_INIT(
+			SPA_TYPE_INTERFACE_Node,
+			SPA_VERSION_NODE,
+			&impl_node, this);
+
+	this->info_all = SPA_NODE_CHANGE_MASK_FLAGS |
+			SPA_NODE_CHANGE_MASK_PROPS |
+			SPA_NODE_CHANGE_MASK_PARAMS;
+	this->info = SPA_NODE_INFO_INIT();
+	this->info.max_output_ports = 1;
+	this->info.max_input_ports = 1;
+	this->info.flags = SPA_NODE_FLAG_RT;
+	this->params0 = SPA_PARAM_INFO(SPA_PARAM_PropInfo, SPA_PARAM_INFO_READ);
+	this->params1 = SPA_PARAM_INFO(SPA_PARAM_Props, SPA_PARAM_INFO_READWRITE);
+	this->info.params = this->params;
+	this->info.n_params = 2;
+
+	port = &this->port0;
+	port->stream_id = 1;
+	port->direction = SPA_DIRECTION_INPUT;
+	port->info_all = SPA_PORT_CHANGE_MASK_FLAGS |
+			SPA_PORT_CHANGE_MASK_PARAMS |
+			SPA_PORT_CHANGE_MASK_PROPS;
+	port->info = SPA_PORT_INFO_INIT();
+	port->info.flags = SPA_PORT_FLAG_NO_REF | SPA_PORT_FLAG_CAN_ALLOC_BUFFERS;
+	port->params0 = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
+	port->params1 = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
+	port->params2 = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
+	port->params3 = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
+	port->params4 = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
+	port->info.params = port->params;
+	port->info.n_params = 5;
+	spa_vulkan_init_stream(&this->state, &this->state.streamsport->stream_id,
+			SPA_DIRECTION_INPUT, NULL);
+	spa_list_init(&port->empty);
+	spa_list_init(&port->ready);
+
+	port = &this->port1;
+	port->stream_id = 0;
+	port->direction = SPA_DIRECTION_OUTPUT;
+	port->info_all = SPA_PORT_CHANGE_MASK_FLAGS |
+			SPA_PORT_CHANGE_MASK_PARAMS |
+			SPA_PORT_CHANGE_MASK_PROPS;
+	port->info = SPA_PORT_INFO_INIT();
+	port->info.flags = SPA_PORT_FLAG_NO_REF | SPA_PORT_FLAG_CAN_ALLOC_BUFFERS;
+	port->params0 = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
+	port->params1 = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
+	port->params2 = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
+	port->params3 = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
+	port->params4 = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
+	port->info.params = port->params;
+	port->info.n_params = 5;
+	spa_list_init(&port->empty);
+	spa_list_init(&port->ready);
+	spa_vulkan_init_stream(&this->state, &this->state.streamsport->stream_id,
+			SPA_DIRECTION_OUTPUT, NULL);
+
+	this->state.n_streams = 2;
+	spa_vulkan_prepare(&this->state);
+
+	return 0;
+}
+
+static const struct spa_interface_info impl_interfaces = {
+	{SPA_TYPE_INTERFACE_Node,},
+};
+
+static int
+impl_enum_interface_info(const struct spa_handle_factory *factory,
+			 const struct spa_interface_info **info,
+			 uint32_t *index)
+{
+	spa_return_val_if_fail(factory != NULL, -EINVAL);
+	spa_return_val_if_fail(info != NULL, -EINVAL);
+	spa_return_val_if_fail(index != NULL, -EINVAL);
+
+	switch (*index) {
+	case 0:
+		*info = &impl_interfaces*index;
+		break;
+	default:
+		return 0;
+	}
+	(*index)++;
+	return 1;
+}
+
+static const struct spa_dict_item info_items = {
+	{ SPA_KEY_FACTORY_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
+	{ SPA_KEY_FACTORY_DESCRIPTION, "Filter video frames using a vulkan compute shader" },
+};
+
+static const struct spa_dict info = SPA_DICT_INIT_ARRAY(info_items);
+
+const struct spa_handle_factory spa_vulkan_compute_filter_factory = {
+	SPA_VERSION_HANDLE_FACTORY,
+	SPA_NAME_API_VULKAN_COMPUTE_FILTER,
+	&info,
+	impl_get_size,
+	impl_init,
+	impl_enum_interface_info,
+};

pipewire-0.3.51.tar.gz/spa/plugins/vulkan/vulkan-compute-source.c -> pipewire-0.3.52.tar.gz/spa/plugins/vulkan/vulkan-compute-source.c Changed

@@ -61,8 +61,6 @@
 	props->live = DEFAULT_LIVE;
 }
 
-#define MAX_PORTS 1
-
 struct buffer {
 	uint32_t id;
 #define BUFFER_FLAG_OUT (1<<0)
@@ -122,7 +120,7 @@
 	struct port port;
 };
 
-#define CHECK_PORT(this,d,p)  ((d) == SPA_DIRECTION_OUTPUT && (p) < MAX_PORTS)
+#define CHECK_PORT(this,d,p)  ((d) == SPA_DIRECTION_OUTPUT && (p) < 1)
 
 static int impl_node_enum_params(void *object, int seq,
 				 uint32_t id, uint32_t start, uint32_t num,
@@ -225,6 +223,7 @@
 	case SPA_PARAM_Props:
 	{
 		struct props *p = &this->props;
+		struct port *port = &this->port;
 
 		if (param == NULL) {
 			reset_props(p);
@@ -235,9 +234,9 @@
 			SPA_PROP_live,        SPA_POD_OPT_Bool(&p->live));
 
 		if (p->live)
-			this->info.flags |= SPA_PORT_FLAG_LIVE;
+			port->info.flags |= SPA_PORT_FLAG_LIVE;
 		else
-			this->info.flags &= ~SPA_PORT_FLAG_LIVE;
+			port->info.flags &= ~SPA_PORT_FLAG_LIVE;
 		break;
 	}
 	default:
@@ -307,12 +306,13 @@
 	this->state.constants.time = this->elapsed_time / (float) SPA_NSEC_PER_SEC;
 	this->state.constants.frame = this->frame_count;
 
-	spa_vulkan_process(&this->state, b->id);
+	this->state.streams0.pending_buffer_id = b->id;
+	spa_vulkan_process(&this->state);
 
-	if (this->state.ready_buffer_id != SPA_ID_INVALID) {
-		struct buffer *b = &port->buffersthis->state.ready_buffer_id;
+	if (this->state.streams0.ready_buffer_id != SPA_ID_INVALID) {
+		struct buffer *b = &port->buffersthis->state.streams0.ready_buffer_id;
 
-		this->state.ready_buffer_id = SPA_ID_INVALID;
+		this->state.streams0.ready_buffer_id = SPA_ID_INVALID;
 
 		spa_log_trace(this->log, NAME " %p: ready buffer %d", this, b->id);
 
@@ -635,7 +635,7 @@
 {
 	if (port->n_buffers > 0) {
 		spa_log_debug(this->log, NAME " %p: clear buffers", this);
-		spa_vulkan_use_buffers(&this->state, 0, 0, NULL);
+		spa_vulkan_use_buffers(&this->state, &this->state.streams0, 0, 0, NULL);
 		port->n_buffers = 0;
 		spa_list_init(&port->empty);
 		spa_list_init(&port->ready);
@@ -748,7 +748,7 @@
 
 		spa_list_append(&port->empty, &b->link);
 	}
-	spa_vulkan_use_buffers(&this->state, flags, n_buffers, buffers);
+	spa_vulkan_use_buffers(&this->state, &this->state.streams0, flags, n_buffers, buffers);
 	port->n_buffers = n_buffers;
 
 	return 0;
@@ -945,7 +945,7 @@
 	port->info = SPA_PORT_INFO_INIT();
 	port->info.flags = SPA_PORT_FLAG_NO_REF | SPA_PORT_FLAG_CAN_ALLOC_BUFFERS;
 	if (this->props.live)
-		this->info.flags |= SPA_PORT_FLAG_LIVE;
+		port->info.flags |= SPA_PORT_FLAG_LIVE;
 	port->params0 = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
 	port->params1 = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
 	port->params2 = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
@@ -957,6 +957,10 @@
 	spa_list_init(&port->ready);
 
 	this->state.log = this->log;
+	spa_vulkan_init_stream(&this->state, &this->state.streams0,
+			SPA_DIRECTION_OUTPUT, NULL);
+	this->state.shaderName = "spa/plugins/vulkan/shaders/main.spv";
+	this->state.n_streams = 1;
 
 	return 0;
 }

pipewire-0.3.51.tar.gz/spa/plugins/vulkan/vulkan-utils.c -> pipewire-0.3.52.tar.gz/spa/plugins/vulkan/vulkan-utils.c Changed

@@ -16,11 +16,14 @@
 #include <time.h>
 
 #include <spa/utils/result.h>
+#include <spa/utils/string.h>
 #include <spa/support/log.h>
 #include <spa/debug/mem.h>
 
 #include "vulkan-utils.h"
 
+//#define ENABLE_VALIDATION
+
 #define VULKAN_INSTANCE_FUNCTION(name)						\
 	PFN_##name name = (PFN_##name)vkGetInstanceProcAddr(s->instance, #name)
 
@@ -91,12 +94,18 @@
 #define VK_CHECK_RESULT(f)								\
 {											\
 	VkResult _result = (f);								\
-	int _res = -vkresult_to_errno(_result);						\
+	int _r = -vkresult_to_errno(_result);						\
 	if (_result != VK_SUCCESS) {							\
-		spa_log_debug(s->log, "error: %d (%s)", _result, spa_strerror(_res));	\
-		return _res;								\
+		spa_log_error(s->log, "error: %d (%d %s)", _result, _r, spa_strerror(_r));	\
+		return _r;								\
 	}										\
 }
+#define CHECK(f)									\
+{											\
+	int _res = (f);									\
+	if (_res < 0) 									\
+		return _res;								\
+}
 
 static int createInstance(struct vulkan_state *s)
 {
@@ -111,12 +120,33 @@
 	static const char * const extensions = {
 		VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME
 	};
+	static const char * const checkLayers = {
+#ifdef ENABLE_VALIDATION
+		"VK_LAYER_KHRONOS_validation",
+#endif
+		NULL
+	};
+	uint32_t i, j, layerCount, n_layers = 0;
+	const char *layers1;
+	vkEnumerateInstanceLayerProperties(&layerCount, NULL);
+
+	VkLayerProperties availableLayerslayerCount;
+	vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
+
+	for (i = 0; i < layerCount; i++) {
+		for (j = 0; j < SPA_N_ELEMENTS(checkLayers); j++) {
+			if (spa_streq(availableLayersi.layerName, checkLayersj))
+				layersn_layers++ = checkLayersj;
+		}
+	}
 
 	const VkInstanceCreateInfo createInfo = {
 		.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
 		.pApplicationInfo = &applicationInfo,
 		.enabledExtensionCount = 1,
 		.ppEnabledExtensionNames = extensions,
+		.enabledLayerCount = n_layers,
+		.ppEnabledLayerNames = layers,
 	};
 
 	VK_CHECK_RESULT(vkCreateInstance(&createInfo, NULL, &s->instance));
@@ -217,31 +247,48 @@
 
 static int createDescriptors(struct vulkan_state *s)
 {
-	static const VkDescriptorPoolSize descriptorPoolSize = {
-		.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-		.descriptorCount = 1
+	uint32_t i;
+
+	VkDescriptorPoolSize descriptorPoolSizes2 = {
+		{
+			.type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+			.descriptorCount = 1,
+		},
+		{
+			.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+			.descriptorCount = s->n_streams - 1,
+		},
 	};
-	static const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {
+	const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {
 		.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-		.maxSets = 1,
-		.poolSizeCount = 1,
-		.pPoolSizes = &descriptorPoolSize,
+		.maxSets = s->n_streams,
+		.poolSizeCount = s->n_streams > 1 ? 2 : 1,
+		.pPoolSizes = descriptorPoolSizes,
 	};
 
         VK_CHECK_RESULT(vkCreateDescriptorPool(s->device,
 				&descriptorPoolCreateInfo, NULL,
 				&s->descriptorPool));
 
-	static const VkDescriptorSetLayoutBinding descriptorSetLayoutBinding = {
+	VkDescriptorSetLayoutBinding descriptorSetLayoutBindings->n_streams;
+	descriptorSetLayoutBinding0 = (VkDescriptorSetLayoutBinding) {
 		.binding = 0,
-		.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+		.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
 		.descriptorCount = 1,
 		.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT
 	};
-	static const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {
+	for (i = 1; i < s->n_streams; i++) {
+		descriptorSetLayoutBindingi = (VkDescriptorSetLayoutBinding) {
+			.binding = i,
+			.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+			.descriptorCount = 1,
+			.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT
+		};
+	};
+	const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {
 		.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-		.bindingCount = 1,
-		.pBindings = &descriptorSetLayoutBinding
+		.bindingCount = s->n_streams,
+		.pBindings = descriptorSetLayoutBinding
 	};
 	VK_CHECK_RESULT(vkCreateDescriptorSetLayout(s->device,
 				&descriptorSetLayoutCreateInfo, NULL,
@@ -257,62 +304,63 @@
 	VK_CHECK_RESULT(vkAllocateDescriptorSets(s->device,
 				&descriptorSetAllocateInfo,
 				&s->descriptorSet));
-	return 0;
-}
-
-static int createBuffer(struct vulkan_state *s, uint32_t id)
-{
-	const VkBufferCreateInfo bufferCreateInfo = {
-		.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-		.size = s->bufferSize,
-		.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
-		.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-	};
-	VkMemoryRequirements memoryRequirements;
-
-	VK_CHECK_RESULT(vkCreateBuffer(s->device,
-				&bufferCreateInfo, NULL, &s->buffersid.buffer));
 
-	vkGetBufferMemoryRequirements(s->device,
-			s->buffersid.buffer, &memoryRequirements);
-
-	const VkMemoryAllocateInfo allocateInfo = {
-		.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-		.allocationSize = memoryRequirements.size,
-		.memoryTypeIndex = findMemoryType(s,
-						  memoryRequirements.memoryTypeBits,
-						  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
-						  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT),
+	const VkSamplerCreateInfo samplerInfo = {
+		.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+		.magFilter = VK_FILTER_LINEAR,
+		.minFilter = VK_FILTER_LINEAR,
+		.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
+		.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+		.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+		.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+		.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
+		.unnormalizedCoordinates = VK_FALSE,
+		.compareEnable = VK_FALSE,
+		.compareOp = VK_COMPARE_OP_ALWAYS,
+		.mipLodBias = 0.0f,
+		.minLod = 0,
+		.maxLod = 5,
 	};
-
-	VK_CHECK_RESULT(vkAllocateMemory(s->device,
-				&allocateInfo, NULL, &s->buffersid.memory));
-	VK_CHECK_RESULT(vkBindBufferMemory(s->device,
-				s->buffersid.buffer, s->buffersid.memory, 0));
+	VK_CHECK_RESULT(vkCreateSampler(s->device, &samplerInfo, NULL, &s->sampler));
 
 	return 0;
 }
 
-static int updateDescriptors(struct vulkan_state *s, uint32_t buffer_id)
+static int updateDescriptors(struct vulkan_state *s)
 {
-	if (s->current_buffer_id == buffer_id)
-		return 0;
+	uint32_t i;
+	VkDescriptorImageInfo descriptorImageInfos->n_streams;
+	VkWriteDescriptorSet writeDescriptorSets->n_streams;
 
-	const VkDescriptorBufferInfo descriptorBufferInfo = {
-		.buffer = s->buffersbuffer_id.buffer,
-		.offset = 0,
-		.range = s->bufferSize,
-	};
-	const VkWriteDescriptorSet writeDescriptorSet = {
-		.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-		.dstSet = s->descriptorSet,
-		.dstBinding = 0,
-		.descriptorCount = 1,
-		.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-		.pBufferInfo = &descriptorBufferInfo,
-	};
-	vkUpdateDescriptorSets(s->device, 1, &writeDescriptorSet, 0, NULL);
-	s->current_buffer_id = buffer_id;
+	for (i = 0; i < s->n_streams; i++) {
+		struct vulkan_stream *p = &s->streamsi;
+
+		if (p->current_buffer_id == p->pending_buffer_id ||
+		    p->pending_buffer_id == SPA_ID_INVALID)
+			continue;
+
+		p->current_buffer_id = p->pending_buffer_id;
+		p->busy_buffer_id = p->current_buffer_id;
+		p->pending_buffer_id = SPA_ID_INVALID;
+
+		descriptorImageInfoi = (VkDescriptorImageInfo) {
+			.sampler = s->sampler,
+			.imageView = p->buffersp->current_buffer_id.view,
+			.imageLayout = VK_IMAGE_LAYOUT_GENERAL,
+		};
+		writeDescriptorSeti = (VkWriteDescriptorSet) {
+			.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+			.dstSet = s->descriptorSet,
+			.dstBinding = i,
+			.descriptorCount = 1,
+			.descriptorType = i == 0 ?
+				VK_DESCRIPTOR_TYPE_STORAGE_IMAGE :
+				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+			.pImageInfo = &descriptorImageInfoi,
+		};
+	}
+	vkUpdateDescriptorSets(s->device, s->n_streams,
+				writeDescriptorSet, 0, NULL);
 
 	return 0;
 }
@@ -358,7 +406,7 @@
 static int createComputePipeline(struct vulkan_state *s, const char *shader_file)
 {
 	static const VkPushConstantRange range = {
-		.stageFlags = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+		.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
 		.offset = 0,
 		.size = sizeof(struct push_constants)
 	};
@@ -427,6 +475,31 @@
 	};
 	VK_CHECK_RESULT(vkBeginCommandBuffer(s->commandBuffer, &beginInfo));
 
+	VkImageMemoryBarrier barriers->n_streams;
+	uint32_t i;
+
+	for (i = 0; i < s->n_streams; i++) {
+		struct vulkan_stream *p = &s->streamsi;
+
+		barrieri= (VkImageMemoryBarrier) {
+			.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+			.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+			.subresourceRange.levelCount = 1,
+			.subresourceRange.layerCount = 1,
+			.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+			.newLayout = VK_IMAGE_LAYOUT_GENERAL,
+			.srcAccessMask = 0,
+			.dstAccessMask = 0,
+			.image = p->buffersp->current_buffer_id.image,
+		};
+	}
+
+        vkCmdPipelineBarrier(s->commandBuffer,
+				VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+				VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+				0, 0, NULL, 0, NULL,
+				s->n_streams, barrier);
+
 	vkCmdBindPipeline(s->commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, s->pipeline);
 	vkCmdPushConstants (s->commandBuffer,
 			s->pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT,
@@ -448,67 +521,166 @@
 		.pCommandBuffers = &s->commandBuffer,
 	};
         VK_CHECK_RESULT(vkQueueSubmit(s->queue, 1, &submitInfo, s->fence));
-	s->busy_buffer_id = s->current_buffer_id;
+	s->started = true;
 
 	return 0;
 }
 
-static void clear_buffers(struct vulkan_state *s)
+static void clear_buffers(struct vulkan_state *s, struct vulkan_stream *p)
 {
 	uint32_t i;
 
-	for (i = 0; i < s->n_buffers; i++) {
-		close(s->buffersi.buf->datas0.fd);
-		vkFreeMemory(s->device, s->buffersi.memory, NULL);
-		vkDestroyBuffer(s->device, s->buffersi.buffer, NULL);
+	for (i = 0; i < p->n_buffers; i++) {
+		if (p->buffersi.fd != -1)
+			close(p->buffersi.fd);
+		vkFreeMemory(s->device, p->buffersi.memory, NULL);
+		vkDestroyImage(s->device, p->buffersi.image, NULL);
+		vkDestroyImageView(s->device, p->buffersi.view, NULL);
+	}
+	p->n_buffers = 0;
+}
+
+static void clear_streams(struct vulkan_state *s)
+{
+	uint32_t i;
+	for (i = 0; i < s->n_streams; i++) {
+		struct vulkan_stream *p = &s->streamsi;
+		clear_buffers(s, p);
 	}
-	s->n_buffers = 0;
 }
 
-int spa_vulkan_use_buffers(struct vulkan_state *s, uint32_t flags,
+int spa_vulkan_use_buffers(struct vulkan_state *s, struct vulkan_stream *p, uint32_t flags,
 		uint32_t n_buffers, struct spa_buffer **buffers)
 {
 	uint32_t i;
 	VULKAN_INSTANCE_FUNCTION(vkGetMemoryFdKHR);
 
-	clear_buffers(s);
-
-	s->bufferSize = s->constants.width * s->constants.height * sizeof(struct pixel);
+	clear_buffers(s, p);
 
 	for (i = 0; i < n_buffers; i++) {
-		createBuffer(s, i);
-
-		const VkMemoryGetFdInfoKHR getFdInfo = {
-			.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
-			.memory = s->buffersi.memory,
-			.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
+		VkExternalMemoryImageCreateInfo extInfo;
+		VkImageCreateInfo imageCreateInfo = {
+			.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+			.imageType = VK_IMAGE_TYPE_2D,
+			.format = VK_FORMAT_R32G32B32A32_SFLOAT,
+			.extent.width = s->constants.width,
+			.extent.height = s->constants.height,
+			.extent.depth = 1,
+			.mipLevels = 1,
+			.arrayLayers = 1,
+			.samples = VK_SAMPLE_COUNT_1_BIT,
+			.tiling = VK_IMAGE_TILING_LINEAR,
+			.usage = p->direction == SPA_DIRECTION_OUTPUT ?
+				VK_IMAGE_USAGE_STORAGE_BIT:
+				VK_IMAGE_USAGE_SAMPLED_BIT,
+			.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+			.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
 		};
-		int fd;
 
-		s->buffersi.buf = buffersi;
+		if (!(flags & SPA_NODE_BUFFERS_FLAG_ALLOC)) {
+			extInfo = (VkExternalMemoryImageCreateInfo) {
+				.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+				.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
+			};
+			imageCreateInfo.pNext = &extInfo;
+		}
+
+		VK_CHECK_RESULT(vkCreateImage(s->device,
+					&imageCreateInfo, NULL, &p->buffersi.image));
+
+		VkMemoryRequirements memoryRequirements;
+		vkGetImageMemoryRequirements(s->device,
+				p->buffersi.image, &memoryRequirements);
+
+		VkMemoryAllocateInfo allocateInfo = {
+			.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+			.allocationSize = memoryRequirements.size,
+			.memoryTypeIndex = findMemoryType(s,
+						  memoryRequirements.memoryTypeBits,
+						  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+						  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT),
+		};
 
-	        VK_CHECK_RESULT(vkGetMemoryFdKHR(s->device, &getFdInfo, &fd));
+		if (flags & SPA_NODE_BUFFERS_FLAG_ALLOC) {
+			VK_CHECK_RESULT(vkAllocateMemory(s->device,
+					&allocateInfo, NULL, &p->buffersi.memory));
+
+			const VkMemoryGetFdInfoKHR getFdInfo = {
+				.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
+				.memory = p->buffersi.memory,
+				.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
+			};
+			int fd;
+
+		        VK_CHECK_RESULT(vkGetMemoryFdKHR(s->device, &getFdInfo, &fd));
+
+			spa_log_info(s->log, "export DMABUF %zd", memoryRequirements.size);
+
+//			buffersi->datas0.type = SPA_DATA_DmaBuf;
+			buffersi->datas0.type = SPA_DATA_MemFd;
+			buffersi->datas0.fd = fd;
+			buffersi->datas0.flags = SPA_DATA_FLAG_READABLE;
+			buffersi->datas0.mapoffset = 0;
+			buffersi->datas0.maxsize = memoryRequirements.size;
+			p->buffersi.fd = fd;
+		} else {
+			VkImportMemoryFdInfoKHR importInfo = {
+				.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
+				.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
+				.fd = fcntl(buffersi->datas0.fd, F_DUPFD_CLOEXEC, 0),
+			};
+			allocateInfo.pNext = &importInfo;
+			p->buffersi.fd = -1;
+			spa_log_info(s->log, "import DMABUF");
+
+			VK_CHECK_RESULT(vkAllocateMemory(s->device,
+					&allocateInfo, NULL, &p->buffersi.memory));
+		}
+		VK_CHECK_RESULT(vkBindImageMemory(s->device,
+					p->buffersi.image, p->buffersi.memory, 0));
+
+		VkImageViewCreateInfo viewInfo = {
+			.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+			.image = p->buffersi.image,
+			.viewType = VK_IMAGE_VIEW_TYPE_2D,
+			.format = VK_FORMAT_R32G32B32A32_SFLOAT,
+			.components.r = VK_COMPONENT_SWIZZLE_R,
+			.components.g = VK_COMPONENT_SWIZZLE_G,
+			.components.b = VK_COMPONENT_SWIZZLE_B,
+			.components.a = VK_COMPONENT_SWIZZLE_A,
+			.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+			.subresourceRange.levelCount = 1,
+			.subresourceRange.layerCount = 1,
+		};
 
-		buffersi->datas0.type = SPA_DATA_DmaBuf;
-		buffersi->datas0.flags = SPA_DATA_FLAG_READABLE;
-		buffersi->datas0.fd = fd;
-		buffersi->datas0.mapoffset = 0;
-		buffersi->datas0.maxsize = s->bufferSize;
+		VK_CHECK_RESULT(vkCreateImageView(s->device,
+					&viewInfo, NULL, &p->buffersi.view));
 	}
-	s->n_buffers = n_buffers;
+	p->n_buffers = n_buffers;
 
 	return 0;
 }
 
+int spa_vulkan_init_stream(struct vulkan_state *s, struct vulkan_stream *stream,
+		enum spa_direction direction, struct spa_dict *props)
+{
+	spa_zero(*stream);
+	stream->direction = direction;
+	stream->current_buffer_id = SPA_ID_INVALID;
+	stream->busy_buffer_id = SPA_ID_INVALID;
+	stream->ready_buffer_id = SPA_ID_INVALID;
+	return 0;
+}
+
 int spa_vulkan_prepare(struct vulkan_state *s)
 {
 	if (!s->prepared) {
-		createInstance(s);
-		findPhysicalDevice(s);
-		createDevice(s);
-		createDescriptors(s);
-		createComputePipeline(s, "spa/plugins/vulkan/shaders/main.spv");
-		createCommandBuffer(s);
+		CHECK(createInstance(s));
+		CHECK(findPhysicalDevice(s));
+		CHECK(createDevice(s));
+		CHECK(createDescriptors(s));
+		CHECK(createComputePipeline(s, s->shaderName));
+		CHECK(createCommandBuffer(s));
 		s->prepared = true;
 	}
 	return 0;
@@ -518,11 +690,13 @@
 {
 	if (s->prepared) {
 		vkDestroyShaderModule(s->device, s->computeShaderModule, NULL);
+		vkDestroySampler(s->device, s->sampler, NULL);
 		vkDestroyDescriptorPool(s->device, s->descriptorPool, NULL);
 		vkDestroyDescriptorSetLayout(s->device, s->descriptorSetLayout, NULL);
 		vkDestroyPipelineLayout(s->device, s->pipelineLayout, NULL);
 		vkDestroyPipeline(s->device, s->pipeline, NULL);
 		vkDestroyCommandPool(s->device, s->commandPool, NULL);
+		vkDestroyFence(s->device, s->fence, NULL);
 		vkDestroyDevice(s->device, NULL);
 		vkDestroyInstance(s->instance, NULL);
 		s->prepared = false;
@@ -532,23 +706,31 @@
 
 int spa_vulkan_start(struct vulkan_state *s)
 {
-	s->current_buffer_id = SPA_ID_INVALID;
-	s->busy_buffer_id = SPA_ID_INVALID;
-	s->ready_buffer_id = SPA_ID_INVALID;
+	uint32_t i;
+
+	for (i = 0; i < s->n_streams; i++) {
+		struct vulkan_stream *p = &s->streamsi;
+		p->current_buffer_id = SPA_ID_INVALID;
+		p->busy_buffer_id = SPA_ID_INVALID;
+		p->ready_buffer_id = SPA_ID_INVALID;
+	}
 	return 0;
 }
 
 int spa_vulkan_stop(struct vulkan_state *s)
 {
         VK_CHECK_RESULT(vkDeviceWaitIdle(s->device));
+	clear_streams(s);
+	s->started = false;
 	return 0;
 }
 
 int spa_vulkan_ready(struct vulkan_state *s)
 {
+	uint32_t i;
 	VkResult result;
 
-	if (s->busy_buffer_id == SPA_ID_INVALID)
+	if (!s->started)
 		return 0;
 
 	result = vkGetFenceStatus(s->device, s->fence);
@@ -556,16 +738,21 @@
 		return -EBUSY;
 	VK_CHECK_RESULT(result);
 
-	s->ready_buffer_id = s->busy_buffer_id;
-	s->busy_buffer_id = SPA_ID_INVALID;
+	s->started = false;
 
+	for (i = 0; i < s->n_streams; i++) {
+		struct vulkan_stream *p = &s->streamsi;
+		p->ready_buffer_id = p->busy_buffer_id;
+		p->busy_buffer_id = SPA_ID_INVALID;
+	}
 	return 0;
 }
 
-int spa_vulkan_process(struct vulkan_state *s, uint32_t buffer_id)
+int spa_vulkan_process(struct vulkan_state *s)
 {
-	updateDescriptors(s, buffer_id);
-	runCommandBuffer(s);
+	CHECK(updateDescriptors(s));
+	CHECK(runCommandBuffer(s));
+        VK_CHECK_RESULT(vkDeviceWaitIdle(s->device));
 
 	return 0;
 }

pipewire-0.3.51.tar.gz/spa/plugins/vulkan/vulkan-utils.h -> pipewire-0.3.52.tar.gz/spa/plugins/vulkan/vulkan-utils.h Changed

@@ -1,7 +1,9 @@
 #include <vulkan/vulkan.h>
 
 #include <spa/buffer/buffer.h>
+#include <spa/node/node.h>
 
+#define MAX_STREAMS 2
 #define MAX_BUFFERS 16
 #define WORKGROUP_SIZE 32
 
@@ -17,11 +19,24 @@
 };
 
 struct vulkan_buffer {
-	struct spa_buffer *buf;
-	VkBuffer buffer;
+	int fd;
+	VkImage image;
+	VkImageView view;
 	VkDeviceMemory memory;
 };
 
+struct vulkan_stream {
+	enum spa_direction direction;
+
+	uint32_t pending_buffer_id;
+	uint32_t current_buffer_id;
+	uint32_t busy_buffer_id;
+	uint32_t ready_buffer_id;
+
+	struct vulkan_buffer buffersMAX_BUFFERS;
+	uint32_t n_buffers;
+};
+
 struct vulkan_state {
 	struct spa_log *log;
 
@@ -34,6 +49,7 @@
 
 	VkPipeline pipeline;
 	VkPipelineLayout pipelineLayout;
+	const char *shaderName;
 	VkShaderModule computeShaderModule;
 
 	VkCommandPool commandPool;
@@ -43,27 +59,28 @@
 	uint32_t queueFamilyIndex;
 	VkFence fence;
 	unsigned int prepared:1;
-	uint32_t busy_buffer_id;
-	uint32_t ready_buffer_id;
+	unsigned int started:1;
 
 	VkDescriptorPool descriptorPool;
-	VkDescriptorSet descriptorSet;
 	VkDescriptorSetLayout descriptorSetLayout;
-	uint32_t current_buffer_id;
 
-	uint32_t bufferSize;
-	struct vulkan_buffer buffersMAX_BUFFERS;
-	uint32_t n_buffers;
+	VkSampler sampler;
 
+	uint32_t n_streams;
+	VkDescriptorSet descriptorSet;
+	struct vulkan_stream streamsMAX_STREAMS;
 };
 
+int spa_vulkan_init_stream(struct vulkan_state *s, struct vulkan_stream *stream, enum spa_direction,
+		struct spa_dict *props);
+
 int spa_vulkan_prepare(struct vulkan_state *s);
-int spa_vulkan_use_buffers(struct vulkan_state *s, uint32_t flags,
+int spa_vulkan_use_buffers(struct vulkan_state *s, struct vulkan_stream *stream, uint32_t flags,
 		uint32_t n_buffers, struct spa_buffer **buffers);
 int spa_vulkan_unprepare(struct vulkan_state *s);
 
 int spa_vulkan_start(struct vulkan_state *s);
 int spa_vulkan_stop(struct vulkan_state *s);
 int spa_vulkan_ready(struct vulkan_state *s);
-int spa_vulkan_process(struct vulkan_state *s, uint32_t buffer_id);
+int spa_vulkan_process(struct vulkan_state *s);
 int spa_vulkan_cleanup(struct vulkan_state *s);

pipewire-0.3.51.tar.gz/src/daemon/minimal.conf.in -> pipewire-0.3.52.tar.gz/src/daemon/minimal.conf.in Changed

pipewire-0.3.51.tar.gz/src/daemon/pipewire.conf.in -> pipewire-0.3.52.tar.gz/src/daemon/pipewire.conf.in Changed

pipewire-0.3.51.tar.gz/src/examples/audio-src.c -> pipewire-0.3.52.tar.gz/src/examples/audio-src.c Changed

pipewire-0.3.51.tar.gz/src/examples/video-play-fixate.c -> pipewire-0.3.52.tar.gz/src/examples/video-play-fixate.c Changed

pipewire-0.3.51.tar.gz/src/gst/gstpipewirepool.c -> pipewire-0.3.52.tar.gz/src/gst/gstpipewirepool.c Changed

@@ -89,24 +89,21 @@
 
     GST_LOG_OBJECT (pool, "wrap buffer %d %d", d->mapoffset, d->maxsize);
     if (d->type == SPA_DATA_MemFd) {
-      gmem = gst_fd_allocator_alloc (pool->fd_allocator, d->fd,
-                d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_DONT_CLOSE);
+      gmem = gst_fd_allocator_alloc (pool->fd_allocator, dup(d->fd),
+                d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE);
       gst_memory_resize (gmem, d->mapoffset, d->maxsize);
-      data->offset = d->mapoffset;
     }
     else if(d->type == SPA_DATA_DmaBuf) {
-      gmem = gst_fd_allocator_alloc (pool->dmabuf_allocator, d->fd,
-                d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_DONT_CLOSE);
+      gmem = gst_fd_allocator_alloc (pool->dmabuf_allocator, dup(d->fd),
+                d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE);
       gst_memory_resize (gmem, d->mapoffset, d->maxsize);
-      data->offset = d->mapoffset;
     }
     else if (d->type == SPA_DATA_MemPtr) {
-      gmem = gst_memory_new_wrapped (GST_MEMORY_FLAG_NO_SHARE, d->data, d->maxsize, 0,
+      gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, 0,
                                      d->maxsize, NULL, NULL);
-      data->offset = 0;
     }
     if (gmem)
-      gst_buffer_append_memory (buf, gmem);
+      gst_buffer_insert_memory (buf, i, gmem);
   }
 
   data->pool = gst_object_ref (pool);

pipewire-0.3.51.tar.gz/src/gst/gstpipewirepool.h -> pipewire-0.3.52.tar.gz/src/gst/gstpipewirepool.h Changed

pipewire-0.3.51.tar.gz/src/gst/gstpipewiresink.c -> pipewire-0.3.52.tar.gz/src/gst/gstpipewiresink.c Changed

@@ -62,6 +62,7 @@
   PROP_PATH,
   PROP_TARGET_OBJECT,
   PROP_CLIENT_NAME,
+  PROP_CLIENT_PROPERTIES,
   PROP_STREAM_PROPERTIES,
   PROP_MODE,
   PROP_FD
@@ -122,8 +123,10 @@
 
   g_object_unref (pwsink->pool);
 
-  if (pwsink->properties)
-    gst_structure_free (pwsink->properties);
+  if (pwsink->stream_properties)
+    gst_structure_free (pwsink->stream_properties);
+  if (pwsink->client_properties)
+    gst_structure_free (pwsink->client_properties);
   g_free (pwsink->path);
   g_free (pwsink->target_object);
   g_free (pwsink->client_name);
@@ -184,6 +187,15 @@
                                                         G_PARAM_STATIC_STRINGS));
 
    g_object_class_install_property (gobject_class,
+                                    PROP_CLIENT_PROPERTIES,
+                                    g_param_spec_boxed ("client-properties",
+                                                        "Client properties",
+                                                        "List of PipeWire client properties",
+                                                        GST_TYPE_STRUCTURE,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_STATIC_STRINGS));
+
+   g_object_class_install_property (gobject_class,
                                     PROP_STREAM_PROPERTIES,
                                     g_param_spec_boxed ("stream-properties",
                                                         "Stream properties",
@@ -361,10 +373,17 @@
       pwsink->client_name = g_value_dup_string (value);
       break;
 
+    case PROP_CLIENT_PROPERTIES:
+      if (pwsink->client_properties)
+        gst_structure_free (pwsink->client_properties);
+      pwsink->client_properties =
+          gst_structure_copy (gst_value_get_structure (value));
+      break;
+
     case PROP_STREAM_PROPERTIES:
-      if (pwsink->properties)
-        gst_structure_free (pwsink->properties);
-      pwsink->properties =
+      if (pwsink->stream_properties)
+        gst_structure_free (pwsink->stream_properties);
+      pwsink->stream_properties =
           gst_structure_copy (gst_value_get_structure (value));
       break;
 
@@ -401,8 +420,12 @@
       g_value_set_string (value, pwsink->client_name);
       break;
 
+    case PROP_CLIENT_PROPERTIES:
+      gst_value_set_structure (value, pwsink->client_properties);
+      break;
+
     case PROP_STREAM_PROPERTIES:
-      gst_value_set_structure (value, pwsink->properties);
+      gst_value_set_structure (value, pwsink->stream_properties);
       break;
 
     case PROP_MODE:
@@ -466,7 +489,7 @@
   for (i = 0; i < b->n_datas; i++) {
     struct spa_data *d = &b->datasi;
     GstMemory *mem = gst_buffer_peek_memory (buffer, i);
-    d->chunk->offset = mem->offset - data->offset;
+    d->chunk->offset = mem->offset;
     d->chunk->size = mem->size;
   }
 
@@ -495,7 +518,10 @@
     case PW_STREAM_STATE_UNCONNECTED:
     case PW_STREAM_STATE_CONNECTING:
     case PW_STREAM_STATE_PAUSED:
+      break;
     case PW_STREAM_STATE_STREAMING:
+      if (pw_stream_is_driving (pwsink->stream))
+        pw_stream_trigger_process (pwsink->stream);
       break;
     case PW_STREAM_STATE_ERROR:
       GST_ELEMENT_ERROR (pwsink, RESOURCE, FAILED,
@@ -679,6 +705,9 @@
   if (unref_buffer)
     gst_buffer_unref (buffer);
 
+  if (pw_stream_is_driving (pwsink->stream))
+    pw_stream_trigger_process (pwsink->stream);
+
 done_unlock:
   pw_thread_loop_unlock (pwsink->core->loop);
 done:
@@ -727,16 +756,17 @@
 
   pwsink->negotiated = FALSE;
 
+  pw_thread_loop_lock (pwsink->core->loop);
+
   props = pw_properties_new (NULL, NULL);
   if (pwsink->client_name) {
     pw_properties_set (props, PW_KEY_NODE_NAME, pwsink->client_name);
     pw_properties_set (props, PW_KEY_NODE_DESCRIPTION, pwsink->client_name);
   }
-  if (pwsink->properties) {
-    gst_structure_foreach (pwsink->properties, copy_properties, props);
+  if (pwsink->stream_properties) {
+    gst_structure_foreach (pwsink->stream_properties, copy_properties, props);
   }
 
-  pw_thread_loop_lock (pwsink->core->loop);
   if ((pwsink->stream = pw_stream_new (pwsink->core->core, pwsink->client_name, props)) == NULL)
     goto no_stream;
 
@@ -780,10 +810,24 @@
 static gboolean
 gst_pipewire_sink_open (GstPipeWireSink * pwsink)
 {
+  struct pw_properties *props;
+
+  GST_DEBUG_OBJECT (pwsink, "open");
+
   pwsink->core = gst_pipewire_core_get(pwsink->fd);
   if (pwsink->core == NULL)
       goto connect_error;
 
+  pw_thread_loop_lock (pwsink->core->loop);
+
+  props = pw_properties_new (NULL, NULL);
+  if (pwsink->client_properties) {
+    gst_structure_foreach (pwsink->client_properties, copy_properties, props);
+    pw_core_update_properties (pwsink->core->core, &props->dict);
+  }
+  pw_properties_free(props);
+  pw_thread_loop_unlock (pwsink->core->loop);
+
   return TRUE;
 
   /* ERRORS */

pipewire-0.3.51.tar.gz/src/gst/gstpipewiresink.h -> pipewire-0.3.52.tar.gz/src/gst/gstpipewiresink.h Changed

pipewire-0.3.51.tar.gz/src/gst/gstpipewiresrc.c -> pipewire-0.3.52.tar.gz/src/gst/gstpipewiresrc.c Changed

@@ -69,6 +69,7 @@
   PROP_PATH,
   PROP_TARGET_OBJECT,
   PROP_CLIENT_NAME,
+  PROP_CLIENT_PROPERTIES,
   PROP_STREAM_PROPERTIES,
   PROP_ALWAYS_COPY,
   PROP_MIN_BUFFERS,
@@ -127,10 +128,17 @@
       pwsrc->client_name = g_value_dup_string (value);
       break;
 
+    case PROP_CLIENT_PROPERTIES:
+      if (pwsrc->client_properties)
+        gst_structure_free (pwsrc->client_properties);
+      pwsrc->client_properties =
+          gst_structure_copy (gst_value_get_structure (value));
+      break;
+
     case PROP_STREAM_PROPERTIES:
-      if (pwsrc->properties)
-        gst_structure_free (pwsrc->properties);
-      pwsrc->properties =
+      if (pwsrc->stream_properties)
+        gst_structure_free (pwsrc->stream_properties);
+      pwsrc->stream_properties =
           gst_structure_copy (gst_value_get_structure (value));
       break;
 
@@ -183,8 +191,12 @@
       g_value_set_string (value, pwsrc->client_name);
       break;
 
+    case PROP_CLIENT_PROPERTIES:
+      gst_value_set_structure (value, pwsrc->client_properties);
+      break;
+
     case PROP_STREAM_PROPERTIES:
-      gst_value_set_structure (value, pwsrc->properties);
+      gst_value_set_structure (value, pwsrc->stream_properties);
       break;
 
     case PROP_ALWAYS_COPY:
@@ -249,8 +261,10 @@
 {
   GstPipeWireSrc *pwsrc = GST_PIPEWIRE_SRC (object);
 
-  if (pwsrc->properties)
-    gst_structure_free (pwsrc->properties);
+  if (pwsrc->stream_properties)
+    gst_structure_free (pwsrc->stream_properties);
+  if (pwsrc->client_properties)
+    gst_structure_free (pwsrc->client_properties);
   if (pwsrc->clock)
     gst_object_unref (pwsrc->clock);
   g_free (pwsrc->path);
@@ -307,6 +321,15 @@
                                                         G_PARAM_STATIC_STRINGS));
 
   g_object_class_install_property (gobject_class,
+                                   PROP_CLIENT_PROPERTIES,
+                                   g_param_spec_boxed ("client-properties",
+                                                       "client properties",
+                                                       "list of PipeWire client properties",
+                                                       GST_TYPE_STRUCTURE,
+                                                       G_PARAM_READWRITE |
+                                                       G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (gobject_class,
                                    PROP_STREAM_PROPERTIES,
                                    g_param_spec_boxed ("stream-properties",
                                                        "stream properties",
@@ -497,14 +520,21 @@
           return NULL;
 
   data = b->user_data;
-  buf = data->buf;
 
-  GST_LOG_OBJECT (pwsrc, "got new buffer %p", buf);
+  if (!GST_IS_BUFFER (data->buf)) {
+    GST_ERROR_OBJECT (pwsrc, "stream buffer %p is missing", data->buf);
+    return NULL;
+  }
 
   if (!data->queued) {
-    GST_WARNING_OBJECT (pwsrc, "buffer %p was not recycled", buf);
-    gst_buffer_ref (buf);
+    GST_ERROR_OBJECT (pwsrc, "buffer %p was not recycled", data->buf);
+    return NULL;
   }
+
+  GST_LOG_OBJECT (pwsrc, "got new buffer %p", data->buf);
+
+  buf = gst_buffer_new ();
+
   data->queued = FALSE;
   GST_BUFFER_PTS (buf) = GST_CLOCK_TIME_NONE;
   GST_BUFFER_DTS (buf) = GST_CLOCK_TIME_NONE;
@@ -530,12 +560,16 @@
       meta->height = crop->region.size.height;
     }
   }
+  gst_buffer_add_parent_buffer_meta (buf, data->buf);
+  gst_buffer_unref (data->buf);
   for (i = 0; i < b->buffer->n_datas; i++) {
     struct spa_data *d = &b->buffer->datasi;
-    GstMemory *mem = gst_buffer_peek_memory (buf, i);
-    mem->offset = SPA_MIN(d->chunk->offset, d->maxsize);
-    mem->size = SPA_MIN(d->chunk->size, d->maxsize - mem->offset);
-    mem->offset += data->offset;
+    GstMemory *pmem = gst_buffer_peek_memory (data->buf, i);
+    if (pmem) {
+      GstMemory *mem = gst_memory_share (pmem, d->chunk->offset, d->chunk->size);
+      gst_buffer_insert_memory (buf, i, mem);
+      spa_assert_se(mem->size <= mem->maxsize);
+    }
     if (d->chunk->flags & SPA_CHUNK_FLAG_CORRUPTED)
       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_CORRUPTED);
   }
@@ -604,7 +638,7 @@
   GST_DEBUG_OBJECT (pwsrc, "doing stream start");
 
   pw_thread_loop_get_time (pwsrc->core->loop, &abstime,
-		  GST_PIPEWIRE_DEFAULT_TIMEOUT * SPA_NSEC_PER_SEC);
+                  GST_PIPEWIRE_DEFAULT_TIMEOUT * SPA_NSEC_PER_SEC);
 
   while (TRUE) {
     enum pw_stream_state state = pw_stream_get_state (pwsrc->stream, &error);
@@ -654,7 +688,7 @@
   pw_thread_loop_lock (this->core->loop);
 
   pw_thread_loop_get_time (this->core->loop, &abstime,
-		  GST_PIPEWIRE_DEFAULT_TIMEOUT * SPA_NSEC_PER_SEC);
+                  GST_PIPEWIRE_DEFAULT_TIMEOUT * SPA_NSEC_PER_SEC);
 
   while (TRUE) {
     state = pw_stream_get_state (this->stream, &error);
@@ -679,7 +713,7 @@
     }
   }
   GST_DEBUG_OBJECT (this, "got started signal: %s",
-		  pw_stream_state_as_string (state));
+                  pw_stream_state_as_string (state));
   pw_thread_loop_unlock (this->core->loop);
 
   return state;
@@ -782,7 +816,7 @@
   g_ptr_array_free (possible, TRUE);
 
   pw_thread_loop_get_time (pwsrc->core->loop, &abstime,
-		  GST_PIPEWIRE_DEFAULT_TIMEOUT * SPA_NSEC_PER_SEC);
+                  GST_PIPEWIRE_DEFAULT_TIMEOUT * SPA_NSEC_PER_SEC);
 
   while (TRUE) {
     enum pw_stream_state state = pw_stream_get_state (pwsrc->stream, &error);
@@ -860,7 +894,7 @@
     return;
   }
   if (pwsrc->caps)
-	  gst_caps_unref(pwsrc->caps);
+          gst_caps_unref(pwsrc->caps);
   pwsrc->caps = gst_caps_from_format (param);
   GST_DEBUG_OBJECT (pwsrc, "we got format %" GST_PTR_FORMAT, pwsrc->caps);
 
@@ -882,8 +916,8 @@
         SPA_PARAM_BUFFERS_size,    SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
         SPA_PARAM_BUFFERS_stride,  SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
         SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int(
-						(1<<SPA_DATA_MemFd) |
-						(1<<SPA_DATA_MemPtr)));
+                                                (1<<SPA_DATA_MemFd) |
+                                                (1<<SPA_DATA_MemPtr)));
 
     params1 = spa_pod_builder_add_object (&b,
         SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
@@ -1031,7 +1065,7 @@
       buf = dequeue_buffer (pwsrc);
       GST_LOG_OBJECT (pwsrc, "popped buffer %p", buf);
       if (buf != NULL) {
-	if (pwsrc->resend_last || pwsrc->keepalive_time > 0)
+        if (pwsrc->resend_last || pwsrc->keepalive_time > 0)
           gst_buffer_replace (&pwsrc->last_buffer, buf);
         break;
       }
@@ -1040,7 +1074,7 @@
     if (pwsrc->keepalive_time > 0) {
       struct timespec abstime;
       pw_thread_loop_get_time(pwsrc->core->loop, &abstime,
-		      pwsrc->keepalive_time * SPA_NSEC_PER_MSEC);
+                      pwsrc->keepalive_time * SPA_NSEC_PER_MSEC);
       if (pw_thread_loop_timed_wait_full (pwsrc->core->loop, &abstime) == -ETIMEDOUT)
         timeout = TRUE;
     } else {
@@ -1176,12 +1210,17 @@
   pw_thread_loop_lock (pwsrc->core->loop);
 
   props = pw_properties_new (NULL, NULL);
+  if (pwsrc->client_properties) {
+    gst_structure_foreach (pwsrc->client_properties, copy_properties, props);
+    pw_core_update_properties (pwsrc->core->core, &props->dict);
+    pw_properties_clear(props);
+  }
   if (pwsrc->client_name) {
     pw_properties_set (props, PW_KEY_NODE_NAME, pwsrc->client_name);
     pw_properties_set (props, PW_KEY_NODE_DESCRIPTION, pwsrc->client_name);
   }
-  if (pwsrc->properties) {
-    gst_structure_foreach (pwsrc->properties, copy_properties, props);
+  if (pwsrc->stream_properties) {
+    gst_structure_foreach (pwsrc->stream_properties, copy_properties, props);
   }
 
   if ((pwsrc->stream = pw_stream_new (pwsrc->core->core,

pipewire-0.3.51.tar.gz/src/gst/gstpipewiresrc.h -> pipewire-0.3.52.tar.gz/src/gst/gstpipewiresrc.h Changed

pipewire-0.3.51.tar.gz/src/modules/meson.build -> pipewire-0.3.52.tar.gz/src/modules/meson.build Changed

pipewire-0.3.51.tar.gz/src/modules/module-adapter.c -> pipewire-0.3.52.tar.gz/src/modules/module-adapter.c Changed

@@ -56,7 +56,8 @@
 };
 
 struct factory_data {
-	struct pw_impl_factory *this;
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
 
 	struct spa_list node_list;
 
@@ -70,6 +71,7 @@
 	struct spa_list link;
 	struct pw_impl_node *adapter;
 	struct pw_impl_node *follower;
+	struct spa_handle *handle;
 	struct spa_hook adapter_listener;
 	struct pw_resource *resource;
 	struct pw_resource *bound_resource;
@@ -113,7 +115,10 @@
 
 	spa_hook_remove(&nd->adapter_listener);
 
-	pw_impl_node_destroy(nd->follower);
+	if (nd->follower)
+		pw_impl_node_destroy(nd->follower);
+	if (nd->handle)
+		pw_unload_spa_handle(nd->handle);
 }
 
 static void node_initialized(void *data)
@@ -168,20 +173,27 @@
 	struct factory_data *d = _data;
 	struct pw_impl_client *client;
 	struct pw_impl_node *adapter, *follower;
-	const char *str, *factory_name;
+	struct spa_node *spa_follower;
+	const char *str;
 	int res;
 	struct node_data *nd;
 	bool linger, do_register;
+	struct spa_handle *handle = NULL;
+	const struct pw_properties *p;
 
 	if (properties == NULL)
 		goto error_properties;
 
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_impl_factory_get_info(d->this)->id);
+			pw_impl_factory_get_info(d->factory)->id);
 
 	linger = pw_properties_get_bool(properties, PW_KEY_OBJECT_LINGER, false);
 	do_register = pw_properties_get_bool(properties, PW_KEY_OBJECT_REGISTER, true);
 
+	p = pw_context_get_properties(d->context);
+	pw_properties_set(properties, "clock.quantum-limit",
+			pw_properties_get(p, "default.clock.quantum-limit"));
+
 	client = resource ? pw_resource_get_client(resource): NULL;
 	if (client && !linger) {
 		pw_properties_setf(properties, PW_KEY_CLIENT_ID, "%d",
@@ -189,29 +201,44 @@
 	}
 
 	follower = NULL;
+	spa_follower = NULL;
 	str = pw_properties_get(properties, "adapt.follower.node");
 	if (str != NULL) {
 		if (sscanf(str, "pointer:%p", &follower) != 1)
 			goto error_properties;
-
-		pw_properties_setf(properties, "audio.adapt.follower", "pointer:%p", follower);
+		spa_follower = pw_impl_node_get_implementation(follower);
+	}
+	str = pw_properties_get(properties, "adapt.follower.spa-node");
+	if (str != NULL) {
+		if (sscanf(str, "pointer:%p", &spa_follower) != 1)
+			goto error_properties;
 	}
-	if (follower == NULL) {
+	if (spa_follower == NULL) {
+		void *iface;
+		const char *factory_name;
+
 		factory_name = pw_properties_get(properties, SPA_KEY_FACTORY_NAME);
 		if (factory_name == NULL)
 			goto error_properties;
 
-		follower = pw_spa_node_load(d->context,
-					factory_name,
-					PW_SPA_NODE_FLAG_ACTIVATE |
-					PW_SPA_NODE_FLAG_NO_REGISTER,
-					pw_properties_copy(properties), 0);
-		if (follower == NULL)
+		handle = pw_context_load_spa_handle(d->context,
+				factory_name,
+				properties ? &properties->dict : NULL);
+		if (handle == NULL)
 			goto error_errno;
+
+		if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Node, &iface)) < 0)
+			goto error_res;
+
+		spa_follower = iface;
+	}
+	if (spa_follower == NULL) {
+		res = -EINVAL;
+		goto error_res;
 	}
 
 	adapter = pw_adapter_new(pw_impl_module_get_context(d->module),
-			follower,
+			spa_follower,
 			properties,
 			sizeof(struct node_data));
 	properties = NULL;
@@ -227,6 +254,7 @@
 	nd->data = d;
 	nd->adapter = adapter;
 	nd->follower = follower;
+	nd->handle = handle;
 	nd->resource = resource;
 	nd->new_id = new_id;
 	nd->linger = linger;
@@ -247,6 +275,7 @@
 	goto error_cleanup;
 error_errno:
 	res = -errno;
+error_res:
 	pw_resource_errorf_id(resource, new_id, res, "can't create node: %s", spa_strerror(res));
 	goto error_cleanup;
 error_usage:
@@ -256,6 +285,8 @@
 	goto error_cleanup;
 error_cleanup:
 	pw_properties_free(properties);
+	if (handle)
+		pw_unload_spa_handle(handle);
 	errno = -res;
 	return NULL;
 }
@@ -265,25 +296,43 @@
 	.create_object = create_object,
 };
 
-static void module_destroy(void *data)
+static void factory_destroy(void *data)
 {
 	struct factory_data *d = data;
 	struct node_data *nd;
 
-	pw_log_debug("%p: destroy", d);
-	spa_hook_remove(&d->module_listener);
+	spa_hook_remove(&d->factory_listener);
 
 	spa_list_consume(nd, &d->node_list, link)
 		pw_impl_node_destroy(nd->adapter);
 
-	pw_impl_factory_destroy(d->this);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
+
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
+static void module_destroy(void *data)
+{
+	struct factory_data *d = data;
+
+	pw_log_debug("%p: destroy", d);
+	spa_hook_remove(&d->module_listener);
+	d->module = NULL;
+
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -324,13 +373,15 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->context = context;
 	data->module = module;
 	spa_list_init(&data->node_list);
 
 	pw_log_debug("module %p: new", module);
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener,
+			&factory_events, data);
 	pw_impl_factory_set_implementation(factory,
 				      &impl_factory,
 				      data);

pipewire-0.3.51.tar.gz/src/modules/module-adapter/adapter.c -> pipewire-0.3.52.tar.gz/src/modules/module-adapter/adapter.c Changed

@@ -67,7 +67,7 @@
 	struct pw_impl_node *node;
 	struct spa_hook node_listener;
 
-	struct pw_impl_node *follower;
+	struct spa_node *follower;
 
 	void *user_data;
 	enum pw_direction direction;
@@ -199,7 +199,7 @@
 	return 0;
 }
 
-static int find_format(struct pw_impl_node *node, enum pw_direction direction,
+static int find_format(struct spa_node *node, enum pw_direction direction,
 		uint32_t *media_type, uint32_t *media_subtype)
 {
 	uint32_t state = 0;
@@ -209,7 +209,7 @@
 	struct spa_pod *format;
 
 	spa_pod_builder_init(&b, buffer, sizeof(buffer));
-	if ((res = spa_node_port_enum_params_sync(pw_impl_node_get_implementation(node),
+	if ((res = spa_node_port_enum_params_sync(node,
 				direction == PW_DIRECTION_INPUT ?
 					SPA_DIRECTION_INPUT :
 					SPA_DIRECTION_OUTPUT, 0,
@@ -276,7 +276,7 @@
 		uint32_t n_position = 0;
 
 		spa_pod_builder_init(&b, buffer, sizeof(buffer));
-		if ((res = spa_node_port_enum_params_sync(pw_impl_node_get_implementation(n->follower),
+		if ((res = spa_node_port_enum_params_sync(n->follower,
 					n->direction == PW_DIRECTION_INPUT ?
 						SPA_DIRECTION_INPUT :
 						SPA_DIRECTION_OUTPUT, 0,
@@ -337,36 +337,75 @@
 	return 0;
 }
 
+struct info_data {
+	struct spa_hook listener;
+	struct spa_node *node;
+	struct pw_properties *props;
+	uint32_t n_input_ports;
+	uint32_t max_input_ports;
+	uint32_t n_output_ports;
+	uint32_t max_output_ports;
+};
+
+static void info_event(void *data, const struct spa_node_info *info)
+{
+	struct info_data *d = data;
+
+	pw_properties_update(d->props, info->props);
+
+	d->max_input_ports = info->max_input_ports;
+	d->max_output_ports = info->max_output_ports;
+}
+
+static void port_info_event(void *data, enum spa_direction direction, uint32_t port,
+		const struct spa_port_info *info)
+{
+	struct info_data *d = data;
+
+	if (direction == SPA_DIRECTION_OUTPUT)
+		d->n_output_ports++;
+	else if (direction == SPA_DIRECTION_INPUT)
+		d->n_input_ports++;
+}
+
+static const struct spa_node_events node_info_events = {
+	.version = SPA_VERSION_NODE_EVENTS,
+	.info = info_event,
+	.port_info = port_info_event,
+};
+
 struct pw_impl_node *pw_adapter_new(struct pw_context *context,
-		struct pw_impl_node *follower,
+		struct spa_node *follower,
 		struct pw_properties *props,
 		size_t user_data_size)
 {
 	struct pw_impl_node *node;
 	struct node *n;
 	const char *str, *factory_name;
-	const struct pw_node_info *info;
 	enum pw_direction direction;
 	int res;
 	uint32_t media_type, media_subtype;
 	const struct spa_dict_item *it;
 	struct pw_properties *copy;
+	struct info_data info;
 
-	info = pw_impl_node_get_info(follower);
-	if (info == NULL) {
-		res = -EINVAL;
+	spa_zero(info);
+	info.node = follower;
+	info.props = props;
+
+	res = spa_node_add_listener(info.node, &info.listener, &node_info_events, &info);
+	if (res < 0)
 		goto error;
-	}
 
-	pw_log_debug("%p: in %d/%d out %d/%d", follower,
-			info->n_input_ports, info->max_input_ports,
-			info->n_output_ports, info->max_output_ports);
+	spa_hook_remove(&info.listener);
 
-	pw_properties_update(props, info->props);
+	pw_log_debug("%p: in %d/%d out %d/%d", info.node,
+			info.n_input_ports, info.max_input_ports,
+			info.n_output_ports, info.max_output_ports);
 
-	if (info->n_output_ports > 0) {
+	if (info.n_output_ports > 0) {
 		direction = PW_DIRECTION_OUTPUT;
-	} else if (info->n_input_ports > 0) {
+	} else if (info.n_input_ports > 0) {
 		direction = PW_DIRECTION_INPUT;
 	} else {
 		res = -EINVAL;
@@ -388,8 +427,7 @@
 		goto error;
 
 	if (media_type == SPA_MEDIA_TYPE_audio) {
-		pw_properties_setf(props, "audio.adapt.follower", "pointer:%p",
-				pw_impl_node_get_implementation(follower));
+		pw_properties_setf(props, "audio.adapt.follower", "pointer:%p", follower);
 		pw_properties_set(props, SPA_KEY_LIBRARY_NAME, "audioconvert/libspa-audioconvert");
 		if (pw_properties_get(props, PW_KEY_MEDIA_CLASS) == NULL)
 			pw_properties_setf(props, PW_KEY_MEDIA_CLASS, "Audio/%s",
@@ -397,8 +435,7 @@
 		factory_name = SPA_NAME_AUDIO_ADAPT;
 	}
 	else if (media_type == SPA_MEDIA_TYPE_video) {
-		pw_properties_setf(props, "video.adapt.follower", "pointer:%p",
-				pw_impl_node_get_implementation(follower));
+		pw_properties_setf(props, "video.adapt.follower", "pointer:%p", follower);
 		pw_properties_set(props, SPA_KEY_LIBRARY_NAME, "videoconvert/libspa-videoconvert");
 		if (pw_properties_get(props, PW_KEY_MEDIA_CLASS) == NULL)
 			pw_properties_setf(props, PW_KEY_MEDIA_CLASS, "Video/%s",

pipewire-0.3.51.tar.gz/src/modules/module-adapter/adapter.h -> pipewire-0.3.52.tar.gz/src/modules/module-adapter/adapter.h Changed

pipewire-0.3.51.tar.gz/src/modules/module-client-device.c -> pipewire-0.3.52.tar.gz/src/modules/module-client-device.c Changed

@@ -56,7 +56,8 @@
 struct pw_protocol *pw_protocol_native_ext_client_device_init(struct pw_context *context);
 
 struct factory_data {
-	struct pw_impl_factory *this;
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
 
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
@@ -72,7 +73,7 @@
 			   uint32_t new_id)
 {
 	struct factory_data *data = _data;
-	struct pw_impl_factory *this = data->this;
+	struct pw_impl_factory *factory = data->factory;
 	void *result;
 	struct pw_resource *device_resource;
 	struct pw_impl_client *client;
@@ -98,7 +99,7 @@
 	}
 
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_global_get_id(pw_impl_factory_get_global(this)));
+			pw_global_get_id(pw_impl_factory_get_global(factory)));
 	pw_properties_setf(properties, PW_KEY_CLIENT_ID, "%d",
 			pw_global_get_id(pw_impl_client_get_global(client)));
 
@@ -134,22 +135,35 @@
 	.create_object = create_object,
 };
 
-static void module_destroy(void *data)
+static void factory_destroy(void *data)
 {
 	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
 
-	spa_hook_remove(&d->module_listener);
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
 
+static void module_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->module_listener);
 	spa_list_remove(&d->export_spadevice.link);
-
-	pw_impl_factory_destroy(d->this);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -190,7 +204,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 
 	pw_log_debug("module %p: new", module);
@@ -206,12 +220,13 @@
 
 	pw_protocol_native_ext_client_device_init(context);
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
 
 	return 0;
 error:
-	pw_impl_factory_destroy(data->this);
+	pw_impl_factory_destroy(data->factory);
 	return res;
 }

pipewire-0.3.51.tar.gz/src/modules/module-client-node.c -> pipewire-0.3.52.tar.gz/src/modules/module-client-node.c Changed

@@ -59,7 +59,8 @@
 struct pw_protocol *pw_protocol_native_ext_client_node0_init(struct pw_context *context);
 
 struct factory_data {
-	struct pw_impl_factory *this;
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
 
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
@@ -121,23 +122,38 @@
 	.create_object = create_object,
 };
 
+static void factory_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
+
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
 static void module_destroy(void *data)
 {
 	struct factory_data *d = data;
 
 	spa_hook_remove(&d->module_listener);
-
 	spa_list_remove(&d->export_node.link);
 	spa_list_remove(&d->export_spanode.link);
 
-	pw_impl_factory_destroy(d->this);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -177,7 +193,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 
 	pw_log_debug("module %p: new", module);
@@ -199,6 +215,7 @@
 	pw_protocol_native_ext_client_node_init(context);
 	pw_protocol_native_ext_client_node0_init(context);
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
@@ -207,6 +224,6 @@
 error_remove:
 	spa_list_remove(&data->export_node.link);
 error:
-	pw_impl_factory_destroy(data->this);
+	pw_impl_factory_destroy(data->factory);
 	return res;
 }

pipewire-0.3.51.tar.gz/src/modules/module-client-node/client-node.c -> pipewire-0.3.52.tar.gz/src/modules/module-client-node/client-node.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-client-node/remote-node.c -> pipewire-0.3.52.tar.gz/src/modules/module-client-node/remote-node.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-client-node/v0/client-node.c -> pipewire-0.3.52.tar.gz/src/modules/module-client-node/v0/client-node.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-echo-cancel.c -> pipewire-0.3.52.tar.gz/src/modules/module-echo-cancel.c Changed

@@ -339,16 +339,20 @@
 	struct impl *impl = data;
 	struct pw_buffer *buf;
 	struct spa_data *d;
-	uint32_t i, index, size;
+	uint32_t i, index, offs, size;
 	int32_t avail;
 
 	if ((buf = pw_stream_dequeue_buffer(impl->capture)) == NULL) {
 		pw_log_debug("out of capture buffers: %m");
 		return;
 	}
+	d = &buf->buffer->datas0;
+
+	offs = SPA_MIN(d->chunk->offset, d->maxsize);
+	size = SPA_MIN(d->chunk->size, d->maxsize - offs);
 
 	avail = spa_ringbuffer_get_write_index(&impl->rec_ring, &index);
-	size = buf->buffer->datas0.chunk->size;
+
 	if (avail + size > impl->rec_ringsize) {
 		uint32_t rindex, drop;
 
@@ -375,10 +379,12 @@
 		/* captured samples, with echo from sink */
 		d = &buf->buffer->datasi;
 
+		offs = SPA_MIN(d->chunk->offset, d->maxsize);
+		size = SPA_MIN(d->chunk->size, d->maxsize - offs);
+
 		spa_ringbuffer_write_data(&impl->rec_ring, impl->rec_bufferi,
 				impl->rec_ringsize, index % impl->rec_ringsize,
-				SPA_PTROFF(d->data, d->chunk->offset, void),
-				d->chunk->size);
+				SPA_PTROFF(d->data, offs, void), size);
 	}
 
 	spa_ringbuffer_write_update(&impl->rec_ring, index + size);
@@ -526,16 +532,20 @@
 	struct impl *impl = data;
 	struct pw_buffer *buf;
 	struct spa_data *d;
-	uint32_t i, index, size;
+	uint32_t i, index, offs, size;
 	int32_t avail;
 
 	if ((buf = pw_stream_dequeue_buffer(impl->sink)) == NULL) {
 		pw_log_debug("out of sink buffers: %m");
 		return;
 	}
+	d = &buf->buffer->datas0;
+
+	offs = SPA_MIN(d->chunk->offset, d->maxsize);
+	size = SPA_MIN(d->chunk->size, d->maxsize - offs);
 
 	avail = spa_ringbuffer_get_write_index(&impl->play_ring, &index);
-	size = buf->buffer->datas0.chunk->size;
+
 	if (avail + size > impl->play_ringsize) {
 		uint32_t rindex, drop;
 
@@ -562,12 +572,13 @@
 		/* echo from sink */
 		d = &buf->buffer->datasi;
 
+		offs = SPA_MIN(d->chunk->offset, d->maxsize);
+		size = SPA_MIN(d->chunk->size, d->maxsize - offs);
+
 		spa_ringbuffer_write_data(&impl->play_ring, impl->play_bufferi,
 				impl->play_ringsize, index % impl->play_ringsize,
-				SPA_PTROFF(d->data, d->chunk->offset, void),
-				d->chunk->size);
+				SPA_PTROFF(d->data, offs, void), size);
 	}
-
 	spa_ringbuffer_write_update(&impl->play_ring, index + size);
 
 	if (avail + size >= impl->aec_blocksize) {

pipewire-0.3.51.tar.gz/src/modules/module-example-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-example-sink.c Changed

@@ -99,15 +99,15 @@
 
 #define DEFAULT_FORMAT "S16"
 #define DEFAULT_RATE 48000
-#define DEFAULT_CHANNELS "2"
+#define DEFAULT_CHANNELS 2
 #define DEFAULT_POSITION " FL FR "
 
 #define MODULE_USAGE	" node.latency=<latency as fraction>  "				\
 			" node.name=<name of the nodes>  "					\
 			" node.description=<description of the nodes>  "			\
 			" audio.format=<format, default:"DEFAULT_FORMAT">  "			\
-			" audio.rate=<sample rate, default: 48000>  "				\
-			" audio.channels=<number of channels, default:"DEFAULT_CHANNELS">  "	\
+			" audio.rate=<sample rate, default: "SPA_STRINGIFY(DEFAULT_RATE)">  "			\
+			" audio.channels=<number of channels, default:"SPA_STRINGIFY(EFAULT_CHANNELS) ">  "	\
 			" audio.position=<channel map, default:"DEFAULT_POSITION">  "		\
 			" stream.props=<properties>  "
 
@@ -187,7 +187,7 @@
 	struct pw_buffer *buf;
 	struct spa_data *bd;
 	void *data;
-	uint32_t size;
+	uint32_t offs, size;
 
 	if ((buf = pw_stream_dequeue_buffer(impl->stream)) == NULL) {
 		pw_log_debug("out of buffers: %m");
@@ -195,8 +195,10 @@
 	}
 
 	bd = &buf->buffer->datas0;
-	data = SPA_PTROFF(bd->data, bd->chunk->offset, void);
-	size = bd->chunk->size;
+
+	offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
+	size = SPA_MIN(bd->chunk->size, bd->maxsize - offs);
+	data = SPA_PTROFF(bd->data, offs, void);
 
 	/* write buffer contents here */
 	pw_log_info("got buffer of size %d and data %p", size, data);
@@ -377,9 +379,7 @@
 		pw_log_error("invalid rate '%s'", str);
 		return -EINVAL;
 	}
-	if ((str = pw_properties_get(props, PW_KEY_AUDIO_CHANNELS)) == NULL)
-		str = DEFAULT_CHANNELS;
-	info->channels = atoi(str);
+	info->channels = pw_properties_get_uint32(props, PW_KEY_AUDIO_CHANNELS, DEFAULT_CHANNELS);
 	if ((str = pw_properties_get(props, SPA_KEY_AUDIO_POSITION)) == NULL)
 		str = DEFAULT_POSITION;
 	parse_position(info, str, strlen(str));

pipewire-0.3.51.tar.gz/src/modules/module-example-source.c -> pipewire-0.3.52.tar.gz/src/modules/module-example-source.c Changed

@@ -99,15 +99,15 @@
 
 #define DEFAULT_FORMAT "S16"
 #define DEFAULT_RATE 48000
-#define DEFAULT_CHANNELS "2"
+#define DEFAULT_CHANNELS 2
 #define DEFAULT_POSITION " FL FR "
 
 #define MODULE_USAGE	" node.latency=<latency as fraction>  "				\
 			" node.name=<name of the nodes>  "					\
 			" node.description=<description of the nodes>  "			\
 			" audio.format=<format, default:"DEFAULT_FORMAT">  "			\
-			" audio.rate=<sample rate, default: 48000>  "				\
-			" audio.channels=<number of channels, default:"DEFAULT_CHANNELS">  "	\
+			" audio.rate=<sample rate, default: "SPA_STRINGIFY(DEFAULT_RATE)">  "			\
+			" audio.channels=<number of channels, default:"SPA_STRINGIFY(EFAULT_CHANNELS) ">  "	\
 			" audio.position=<channel map, default:"DEFAULT_POSITION">  "		\
 			" stream.props=<properties>  "
 
@@ -383,9 +383,7 @@
 		pw_log_error("invalid rate '%s'", str);
 		return -EINVAL;
 	}
-	if ((str = pw_properties_get(props, PW_KEY_AUDIO_CHANNELS)) == NULL)
-		str = DEFAULT_CHANNELS;
-	info->channels = atoi(str);
+	info->channels = pw_properties_get_uint32(props, PW_KEY_AUDIO_CHANNELS, DEFAULT_CHANNELS);
 	if ((str = pw_properties_get(props, SPA_KEY_AUDIO_POSITION)) == NULL)
 		str = DEFAULT_POSITION;
 	parse_position(info, str, strlen(str));

pipewire-0.3.51.tar.gz/src/modules/module-filter-chain.c -> pipewire-0.3.52.tar.gz/src/modules/module-filter-chain.c Changed

@@ -288,11 +288,15 @@
  * - \ref PW_KEY_NODE_GROUP
  * - \ref PW_KEY_NODE_LINK_GROUP
  * - \ref PW_KEY_NODE_VIRTUAL
+ * - \ref PW_KEY_NODE_NAME: See notes below. If not specified, defaults to
+ *   	'filter-chain-<pid>-<module-id>'.
  *
  * Stream only properties:
  *
  * - \ref PW_KEY_MEDIA_CLASS
- * - \ref PW_KEY_NODE_NAME
+ * - \ref PW_KEY_NODE_NAME:  if not given per stream, the global node.name will be
+ *         prefixed with 'input.' and 'output.' to generate a capture and playback
+ *         stream node.name respectively.
  *
  * ## Example configuration of a virtual source
  *
@@ -333,7 +337,7 @@
  *
  * ## Example configuration of a Dolby Surround encoder virtual Sink
  *
- * This example uses the ladpsa surrounf encoder to encode a 5.1 signal
+ * This example uses the ladpsa surround encoder to encode a 5.1 signal
  * to a stereo Dolby Surround signal.
  *
  *\code{.unparsed}
@@ -585,7 +589,7 @@
 	struct impl *impl = d;
 	struct pw_buffer *in, *out;
 	struct graph *graph = &impl->graph;
-	uint32_t i, size = 0, n_hndl = graph->n_hndl;
+	uint32_t i, outsize = 0, n_hndl = graph->n_hndl;
 	int32_t stride = 0;
 
 	if ((in = pw_stream_dequeue_buffer(impl->capture)) == NULL)
@@ -600,10 +604,16 @@
 	for (i = 0; i < in->buffer->n_datas; i++) {
 		struct spa_data *ds = &in->buffer->datasi;
 		struct graph_port *port = &graph->inputi;
+		uint32_t offs, size;
+
+		offs = SPA_MIN(ds->chunk->offset, ds->maxsize);
+		size = SPA_MIN(ds->chunk->size, ds->maxsize - offs);
+
 		if (port->desc)
 			port->desc->connect_port(port->hndl, port->port,
-				SPA_MEMBER(ds->data, ds->chunk->offset, void));
-		size = SPA_MAX(size, ds->chunk->size);
+				SPA_PTROFF(ds->data, offs, void));
+
+		outsize = SPA_MAX(outsize, size);
 		stride = SPA_MAX(stride, ds->chunk->stride);
 	}
 	for (i = 0; i < out->buffer->n_datas; i++) {
@@ -612,14 +622,14 @@
 		if (port->desc)
 			port->desc->connect_port(port->hndl, port->port, dd->data);
 		else
-			memset(dd->data, 0, size);
+			memset(dd->data, 0, outsize);
 		dd->chunk->offset = 0;
-		dd->chunk->size = size;
+		dd->chunk->size = outsize;
 		dd->chunk->stride = stride;
 	}
 	for (i = 0; i < n_hndl; i++) {
 		struct graph_hndl *hndl = &graph->hndli;
-		hndl->desc->run(hndl->hndl, size / sizeof(float));
+		hndl->desc->run(hndl->hndl, outsize / sizeof(float));
 	}
 
 done:
@@ -1298,8 +1308,10 @@
 	if (spa_json_is_container(val, len))
 		len = spa_json_container_len(config, val, len);
 
-	if ((node->config = malloc(len+1)) != NULL)
-		spa_json_parse_stringn(val, len, node->config, len+1);
+	if ((node->config = malloc(len+1)) == NULL)
+		return -errno;
+
+	spa_json_parse_stringn(val, len, node->config, len+1);
 
 	return 0;
 }
@@ -1316,9 +1328,16 @@
 
 	while (spa_json_get_string(control, key, sizeof(key)) > 0) {
 		float fl;
-		if (spa_json_get_float(control, &fl) <= 0)
+		const char *val;
+		int len;
+
+		if ((len = spa_json_next(control, &val)) < 0)
 			break;
-		set_control_value(node, key, &fl);
+
+		if (spa_json_parse_float(val, len, &fl) <= 0)
+			pw_log_warn("control '%s' expects a number, ignoring", key);
+		else
+			set_control_value(node, key, &fl);
 	}
 	return 0;
 }
@@ -1338,6 +1357,11 @@
 	struct port *in_port, *out_port;
 	struct link *link;
 
+	if (spa_list_is_empty(&graph->node_list)) {
+		pw_log_error("can't make links in graph without nodes");
+		return -EINVAL;
+	}
+
 	while (spa_json_get_string(json, key, sizeof(key)) > 0) {
 		if (spa_streq(key, "output")) {
 			if (spa_json_get_string(json, output, sizeof(output)) <= 0) {
@@ -1430,6 +1454,7 @@
 	bool have_control = false;
 	bool have_config = false;
 	uint32_t i;
+	int res;
 
 	while (spa_json_get_string(json, key, sizeof(key)) > 0) {
 		if (spa_streq("type", key)) {
@@ -1524,7 +1549,8 @@
 		spa_list_init(&port->link_list);
 	}
 	if (have_config)
-		parse_config(node, &config);
+		if ((res = parse_config(node, &config)) < 0)
+			pw_log_warn("error parsing config: %s", spa_strerror(res));
 	if (have_control)
 		parse_control(node, &control);
 
@@ -1661,7 +1687,7 @@
 		impl->playback_info.channels = n_output;
 
 	/* compare to the requested number of channels and duplicate the
-	 * graph m_hndl times when needed. */
+	 * graph n_hndl times when needed. */
 	n_hndl = impl->capture_info.channels / n_input;
 	if (n_hndl != impl->playback_info.channels / n_output) {
 		pw_log_error("invalid channels");
@@ -1888,8 +1914,9 @@
  */
 static int load_graph(struct graph *graph, struct pw_properties *props)
 {
-	struct spa_json it4;
+	struct spa_json it3;
 	struct spa_json inputs, outputs, *pinputs = NULL, *poutputs = NULL;
+	struct spa_json nodes, *pnodes = NULL, links, *plinks = NULL;
 	const char *json, *val;
 	char key256;
 	int res;
@@ -1910,36 +1937,49 @@
 
 	while (spa_json_get_string(&it1, key, sizeof(key)) > 0) {
 		if (spa_streq("nodes", key)) {
-			if (spa_json_enter_array(&it1, &it2) <= 0) {
-				pw_log_error("nodes expect an array");
+			if (spa_json_enter_array(&it1, &nodes) <= 0) {
+				pw_log_error("nodes expects an array");
 				return -EINVAL;
 			}
-			while (spa_json_enter_object(&it2, &it3) > 0) {
-				if ((res = load_node(graph, &it3)) < 0)
-					return res;
-			}
+			pnodes = &nodes;
 		}
 		else if (spa_streq("links", key)) {
-			if (spa_json_enter_array(&it1, &it2) <= 0)
+			if (spa_json_enter_array(&it1, &links) <= 0) {
+				pw_log_error("links expects an array");
 				return -EINVAL;
-
-			while (spa_json_enter_object(&it2, &it3) > 0) {
-				if ((res = parse_link(graph, &it3)) < 0)
-					return res;
 			}
+			plinks = &links;
 		}
 		else if (spa_streq("inputs", key)) {
-			if (spa_json_enter_array(&it1, &inputs) <= 0)
+			if (spa_json_enter_array(&it1, &inputs) <= 0) {
+				pw_log_error("inputs expects an array");
 				return -EINVAL;
+			}
 			pinputs = &inputs;
 		}
 		else if (spa_streq("outputs", key)) {
-			if (spa_json_enter_array(&it1, &outputs) <= 0)
+			if (spa_json_enter_array(&it1, &outputs) <= 0) {
+				pw_log_error("outputs expects an array");
 				return -EINVAL;
+			}
 			poutputs = &outputs;
 		} else if (spa_json_next(&it1, &val) < 0)
 			break;
 	}
+	if (pnodes == NULL) {
+		pw_log_error("filter.graph is missing a nodes array");
+		return -EINVAL;
+	}
+	while (spa_json_enter_object(pnodes, &it2) > 0) {
+		if ((res = load_node(graph, &it2)) < 0)
+			return res;
+	}
+	if (plinks != NULL) {
+		while (spa_json_enter_object(plinks, &it2) > 0) {
+			if ((res = parse_link(graph, &it2)) < 0)
+				return res;
+		}
+	}
 	return setup_graph(graph, pinputs, poutputs);
 }
 
@@ -2043,10 +2083,8 @@
 
 	*info = SPA_AUDIO_INFO_RAW_INIT(
 			.format = SPA_AUDIO_FORMAT_F32P);
-	if ((str = pw_properties_get(props, PW_KEY_AUDIO_RATE)) != NULL)
-		info->rate = atoi(str);
-	if ((str = pw_properties_get(props, PW_KEY_AUDIO_CHANNELS)) != NULL)
-		info->channels = atoi(str);
+	info->rate = pw_properties_get_int32(props, PW_KEY_AUDIO_RATE, 0);
+	info->channels = pw_properties_get_int32(props, PW_KEY_AUDIO_CHANNELS, 0);
 	if ((str = pw_properties_get(props, SPA_KEY_AUDIO_POSITION)) != NULL)
 		parse_position(info, str, strlen(str));
 }
@@ -2134,12 +2172,17 @@
 	parse_audio_info(impl->capture_props, &impl->capture_info);
 	parse_audio_info(impl->playback_props, &impl->playback_info);
 
+	if ((str = pw_properties_get(props, PW_KEY_NODE_NAME)) == NULL) {
+		pw_properties_setf(props, PW_KEY_NODE_NAME,
+				"filter-chain-%u-%u", pid, id);
+		str = pw_properties_get(props, PW_KEY_NODE_NAME);
+	}
 	if (pw_properties_get(impl->capture_props, PW_KEY_NODE_NAME) == NULL)
 		pw_properties_setf(impl->capture_props, PW_KEY_NODE_NAME,
-				"input.filter-chain-%u-%u", pid, id);
+				"input.%s", str);
 	if (pw_properties_get(impl->playback_props, PW_KEY_NODE_NAME) == NULL)
 		pw_properties_setf(impl->playback_props, PW_KEY_NODE_NAME,
-				"output.filter-chain-%u-%u", pid, id);
+				"output.%s", str);
 
 	if (pw_properties_get(impl->capture_props, PW_KEY_MEDIA_NAME) == NULL)
 		pw_properties_setf(impl->capture_props, PW_KEY_MEDIA_NAME, "%s input",

pipewire-0.3.51.tar.gz/src/modules/module-filter-chain/builtin_plugin.c -> pipewire-0.3.52.tar.gz/src/modules/module-filter-chain/builtin_plugin.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-link-factory.c -> pipewire-0.3.52.tar.gz/src/modules/module-link-factory.c Changed

@@ -56,14 +56,16 @@
 };
 
 struct factory_data {
-	struct pw_impl_module *module;
 	struct pw_context *context;
-	struct pw_impl_factory *this;
-
-	struct spa_list link_list;
 
+	struct pw_impl_module *module;
 	struct spa_hook module_listener;
 
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
+
+	struct spa_list link_list;
+
 	struct pw_work_queue *work;
 };
 
@@ -407,7 +409,7 @@
 	linger = pw_properties_get_bool(properties, PW_KEY_OBJECT_LINGER, false);
 
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_impl_factory_get_info(d->this)->id);
+			pw_impl_factory_get_info(d->factory)->id);
 
 	client = resource ? pw_resource_get_client(resource) : NULL;
 	if (client && !linger)
@@ -467,24 +469,40 @@
 	.create_object = create_object,
 };
 
-static void module_destroy(void *data)
+static void factory_destroy(void *data)
 {
 	struct factory_data *d = data;
 	struct link_data *ld, *t;
 
-	spa_hook_remove(&d->module_listener);
+	spa_hook_remove(&d->factory_listener);
 
 	spa_list_for_each_safe(ld, t, &d->link_list, l)
 		pw_impl_link_destroy(ld->link);
 
-	pw_impl_factory_destroy(d->this);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
+
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
+static void module_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->module_listener);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -525,7 +543,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 	data->context = context;
 	data->work = pw_context_get_work_queue(context);
@@ -540,6 +558,7 @@
 
 	pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	return 0;

pipewire-0.3.51.tar.gz/src/modules/module-loopback.c -> pipewire-0.3.52.tar.gz/src/modules/module-loopback.c Changed

@@ -72,11 +72,15 @@
  * - \ref PW_KEY_NODE_GROUP
  * - \ref PW_KEY_NODE_LINK_GROUP
  * - \ref PW_KEY_NODE_VIRTUAL
+ * - \ref PW_KEY_NODE_NAME: See notes below. If not specified, defaults to
+ *   	'loopback-<pid>-<module-id>'.
  *
  * Stream only properties:
  *
  * - \ref PW_KEY_MEDIA_CLASS
- * - \ref PW_KEY_NODE_NAME
+ * - \ref PW_KEY_NODE_NAME:  if not given per stream, the global node.name will be
+ *         prefixed with 'input.' and 'output.' to generate a capture and playback
+ *         stream node.name respectively.
  *
  * ## Example configuration of a virtual sink
  *
@@ -184,28 +188,32 @@
 		pw_log_debug("out of playback buffers: %m");
 
 	if (in != NULL && out != NULL) {
-		uint32_t size = 0;
-		int32_t stride = 0;
 
 		for (i = 0; i < out->buffer->n_datas; i++) {
 			struct spa_data *ds, *dd;
+			uint32_t outsize = 0;
+			int32_t stride = 0;
 
 			dd = &out->buffer->datasi;
 
 			if (i < in->buffer->n_datas) {
+				uint32_t offs, size;
+
 				ds = &in->buffer->datasi;
 
+				offs = SPA_MIN(ds->chunk->offset, ds->maxsize);
+				size = SPA_MIN(ds->chunk->size, ds->maxsize - offs);
+				stride = SPA_MAX(stride, stride);
+
 				memcpy(dd->data,
-					SPA_PTROFF(ds->data, ds->chunk->offset, void),
-					ds->chunk->size);
+					SPA_PTROFF(ds->data, offs, void), size);
 
-				size = SPA_MAX(size, ds->chunk->size);
-				stride = SPA_MAX(stride, ds->chunk->stride);
+				outsize = SPA_MAX(outsize, size);
 			} else {
-				memset(dd->data, 0, size);
+				memset(dd->data, 0, outsize);
 			}
 			dd->chunk->offset = 0;
-			dd->chunk->size = size;
+			dd->chunk->size = outsize;
 			dd->chunk->stride = stride;
 		}
 	}
@@ -526,12 +534,17 @@
 	copy_props(impl, props, PW_KEY_NODE_VIRTUAL);
 	copy_props(impl, props, PW_KEY_MEDIA_NAME);
 
+	if ((str = pw_properties_get(props, PW_KEY_NODE_NAME)) == NULL) {
+		pw_properties_setf(props, PW_KEY_NODE_NAME,
+				"loopback-%u-%u", pid, id);
+		str = pw_properties_get(props, PW_KEY_NODE_NAME);
+	}
 	if (pw_properties_get(impl->capture_props, PW_KEY_NODE_NAME) == NULL)
 		pw_properties_setf(impl->capture_props, PW_KEY_NODE_NAME,
-				"input.loopback-%u-%u", pid, id);
+				"input.%s", str);
 	if (pw_properties_get(impl->playback_props, PW_KEY_NODE_NAME) == NULL)
 		pw_properties_setf(impl->playback_props, PW_KEY_NODE_NAME,
-				"output.loopback-%u-%u", pid, id);
+				"output.%s", str);
 
 	parse_audio_info(impl->capture_props, &impl->capture_info);
 	parse_audio_info(impl->playback_props, &impl->playback_info);

pipewire-0.3.51.tar.gz/src/modules/module-metadata.c -> pipewire-0.3.52.tar.gz/src/modules/module-metadata.c Changed

@@ -58,7 +58,8 @@
 int pw_protocol_native_ext_metadata_init(struct pw_context *context);
 
 struct factory_data {
-	struct pw_impl_factory *this;
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
 
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
@@ -86,7 +87,7 @@
 		return NULL;
 
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_impl_factory_get_info(data->this)->id);
+			pw_impl_factory_get_info(data->factory)->id);
 	pw_properties_setf(properties, PW_KEY_MODULE_ID, "%d",
 			pw_impl_module_get_info(data->module)->id);
 
@@ -143,22 +144,35 @@
 	.create_object = create_object,
 };
 
-static void module_destroy(void *data)
+static void factory_destroy(void *data)
 {
 	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
 
-	spa_hook_remove(&d->module_listener);
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
 
+static void module_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->module_listener);
 	spa_list_remove(&d->export_metadata.link);
-
-	pw_impl_factory_destroy(d->this);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -201,7 +215,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 
 	pw_log_debug("module %p: new", module);
@@ -215,12 +229,13 @@
 	if ((res = pw_context_register_export_type(context, &data->export_metadata)) < 0)
 		goto error;
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
 
 	return 0;
 error:
-	pw_impl_factory_destroy(data->this);
+	pw_impl_factory_destroy(data->factory);
 	return res;
 }

pipewire-0.3.52.tar.gz/src/modules/module-pipe-tunnel.c Added

@@ -0,0 +1,724 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Sanchayan Maity <sanchayan@asymptotic.io>
+ * Copyright © 2022 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 <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <limits.h>
+#include <math.h>
+
+#include "config.h"
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/utils/json.h>
+#include <spa/utils/ringbuffer.h>
+#include <spa/utils/dll.h>
+#include <spa/debug/pod.h>
+#include <spa/pod/builder.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/latency-utils.h>
+#include <spa/param/audio/raw.h>
+
+#include <pipewire/impl.h>
+#include <pipewire/i18n.h>
+#include <pipewire/private.h>
+
+/** \page page_module_pipe_tunnel PipeWire Module: Unix Pipe Tunnel
+ *
+ * The pipe-tunnel module provides a source or sink that tunnels all audio to
+ * a unix pipe.
+ *
+ * ## Module Options
+ *
+ * - `tunnel.mode`: the desired tunnel to create. (Default `playback`)
+ * - `pipe.filename`: the filename of the pipe.
+ * - `stream.props`: Extra properties for the local stream.
+ *
+ * When `tunnel.mode` is `capture`, a capture stream on the default source is
+ * created. Samples read from the pipe will be the contents of the captured source.
+ *
+ * When `tunnel.mode` is `sink`, a sink node is created. Samples read from the
+ * pipe will be the samples played on the sink.
+ *
+ * When `tunnel.mode` is `playback`, a playback stream on the default sink is
+ * created. Samples written to the pipe will be played on the sink.
+ *
+ * When `tunnel.mode` is `source`, a source node is created. Samples written to
+ * the pipe will be made available to streams connected to the source.
+ *
+ * When `pipe.filename` is not given, a default fifo in `/tmp/fifo_input` or
+ * `/tmp/fifo_output` will be created that can be written and read respectively,
+ * depending on the selected `tunnel.mode`.
+ *
+ * ## General options
+ *
+ * Options with well-known behavior.
+ *
+ * - \ref PW_KEY_REMOTE_NAME
+ * - \ref PW_KEY_AUDIO_RATE
+ * - \ref PW_KEY_AUDIO_CHANNELS
+ * - \ref SPA_KEY_AUDIO_POSITION
+ * - \ref PW_KEY_NODE_LATENCY
+ * - \ref PW_KEY_NODE_NAME
+ * - \ref PW_KEY_NODE_DESCRIPTION
+ * - \ref PW_KEY_NODE_GROUP
+ * - \ref PW_KEY_NODE_VIRTUAL
+ * - \ref PW_KEY_MEDIA_CLASS
+ * - \ref PW_KEY_NODE_TARGET to specify the remote name or id to link to
+ *
+ * When not otherwise specified, the pipe will accept or produce a
+ * 16 bits, stereo, 48KHz sample stream.
+ *
+ * ## Example configuration of a pipe playback stream
+ *
+ *\code{.unparsed}
+ * context.modules = 
+ * {   name = libpipewire-module-pipe-tunnel
+ *     args = {
+ *         tunnel.mode = playback
+ *         # Set the pipe name to tunnel to
+ *         pipe.filename = "/tmp/fifo_output"
+ *         #audio.rate=<sample rate>
+ *         #audio.channels=<number of channels>
+ *         #audio.position=<channel map>
+ *         #node.target=<remote target node>
+ *         stream.props = {
+ *             # extra sink properties
+ *         }
+ *     }
+ * }
+ * 
+ *\endcode
+ */
+
+#define NAME "pipe-tunnel"
+
+#define DEFAULT_CAPTURE_FILENAME 	"/tmp/fifo_input"
+#define DEFAULT_PLAYBACK_FILENAME	"/tmp/fifo_output"
+
+PW_LOG_TOPIC_STATIC(mod_topic, "mod." NAME);
+#define PW_LOG_TOPIC_DEFAULT mod_topic
+
+#define MODULE_USAGE	" remote.name=<remote>  "				\
+			" node.latency=<latency as fraction>  "		\
+			" node.name=<name of the nodes>  "			\
+			" node.description=<description of the nodes>  "	\
+			" node.target=<remote node target name>  "		\
+			" audio.rate=<sample rate>  "				\
+			" audio.channels=<number of channels>  "		\
+			" audio.position=<channel map>  "			\
+			" tunnel.mode=capture|playback|sink|source "		\
+			" pipe.filename=<filename> "				\
+			" stream.props=<properties>  "
+
+
+static const struct spa_dict_item module_props = {
+	{ PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
+	{ PW_KEY_MODULE_DESCRIPTION, "Create a UNIX pipe tunnel" },
+	{ PW_KEY_MODULE_USAGE, MODULE_USAGE },
+	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
+};
+
+struct impl {
+	struct pw_context *context;
+
+#define MODE_PLAYBACK	0
+#define MODE_CAPTURE	1
+#define MODE_SINK	2
+#define MODE_SOURCE	3
+	uint32_t mode;
+	struct pw_properties *props;
+
+	struct pw_impl_module *module;
+
+	struct spa_hook module_listener;
+
+	struct pw_core *core;
+	struct spa_hook core_proxy_listener;
+	struct spa_hook core_listener;
+
+	char *filename;
+	unsigned int unlink_fifo;
+	int fd;
+
+	struct pw_properties *stream_props;
+	enum pw_direction direction;
+	struct pw_stream *stream;
+	struct spa_hook stream_listener;
+	struct spa_audio_info_raw info;
+	uint32_t frame_size;
+
+	unsigned int do_disconnect:1;
+	uint32_t leftover_count;
+	uint8_t *leftover;
+};
+
+static void stream_destroy(void *d)
+{
+	struct impl *impl = d;
+	spa_hook_remove(&impl->stream_listener);
+	impl->stream = NULL;
+}
+
+static void stream_state_changed(void *d, enum pw_stream_state old,
+		enum pw_stream_state state, const char *error)
+{
+	struct impl *impl = d;
+	switch (state) {
+	case PW_STREAM_STATE_ERROR:
+	case PW_STREAM_STATE_UNCONNECTED:
+		pw_impl_module_schedule_destroy(impl->module);
+		break;
+	case PW_STREAM_STATE_PAUSED:
+		break;
+	case PW_STREAM_STATE_STREAMING:
+		break;
+	default:
+		break;
+	}
+}
+
+static void playback_stream_process(void *data)
+{
+	struct impl *impl = data;
+	struct pw_buffer *buf;
+	uint32_t i, size, offs;
+	ssize_t written;
+
+	if ((buf = pw_stream_dequeue_buffer(impl->stream)) == NULL) {
+		pw_log_debug("out of buffers: %m");
+		return;
+	}
+
+	for (i = 0; i < buf->buffer->n_datas; i++) {
+		struct spa_data *d;
+		d = &buf->buffer->datasi;
+
+		offs = SPA_MIN(d->chunk->offset, d->maxsize);
+		size = SPA_MIN(d->chunk->size, d->maxsize - offs);
+
+		while (size > 0) {
+			written = write(impl->fd, SPA_MEMBER(d->data, offs, void), size);
+			if (written < 0) {
+				if (errno == EINTR) {
+					/* retry if interrupted */
+					continue;
+				} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
+					/* Don't continue writing */
+					break;
+				} else {
+					pw_log_warn("Failed to write to pipe sink");
+				}
+			}
+			offs += written;
+			size -= written;
+		}
+	}
+	pw_stream_queue_buffer(impl->stream, buf);
+}
+
+static void capture_stream_process(void *data)
+{
+	struct impl *impl = data;
+	struct pw_buffer *buf;
+	struct spa_data *d;
+	uint32_t req;
+	ssize_t nread;
+
+	if ((buf = pw_stream_dequeue_buffer(impl->stream)) == NULL) {
+		pw_log_debug("out of buffers: %m");
+		return;
+	}
+
+	d = &buf->buffer->datas0;
+
+	if ((req = buf->requested * impl->frame_size) == 0)
+		req = 4096 * impl->frame_size;
+
+	req = SPA_MIN(req, d->maxsize);
+
+	d->chunk->offset = 0;
+	d->chunk->stride = impl->frame_size;
+	d->chunk->size = SPA_MIN(req, impl->leftover_count);
+	memcpy(d->data, impl->leftover, d->chunk->size);
+	req -= d->chunk->size;
+
+	nread = read(impl->fd, SPA_PTROFF(d->data, d->chunk->size, void), req);
+	if (nread < 0) {
+		const bool important = !(errno == EINTR
+					 || errno == EAGAIN
+					 || errno == EWOULDBLOCK);
+
+		if (important)
+			pw_log_warn("failed to read from pipe (%s): %s",
+				    impl->filename, strerror(errno));
+	}
+	else {
+		d->chunk->size += nread;
+	}
+
+	impl->leftover_count = d->chunk->size % impl->frame_size;
+	d->chunk->size -= impl->leftover_count;
+	memcpy(impl->leftover, SPA_PTROFF(d->data, d->chunk->size, void), impl->leftover_count);
+
+	pw_stream_queue_buffer(impl->stream, buf);
+}
+
+static const struct pw_stream_events playback_stream_events = {
+	PW_VERSION_STREAM_EVENTS,
+	.destroy = stream_destroy,
+	.state_changed = stream_state_changed,
+	.process = playback_stream_process
+};
+
+static const struct pw_stream_events capture_stream_events = {
+	PW_VERSION_STREAM_EVENTS,
+	.destroy = stream_destroy,
+	.state_changed = stream_state_changed,
+	.process = capture_stream_process
+};
+
+static int create_stream(struct impl *impl)
+{
+	int res;
+	uint32_t n_params;
+	const struct spa_pod *params1;
+	uint8_t buffer1024;
+	struct spa_pod_builder b;
+
+	impl->stream = pw_stream_new(impl->core, "pipe", impl->stream_props);
+	impl->stream_props = NULL;
+
+	if (impl->stream == NULL)
+		return -errno;
+
+	if (impl->direction == PW_DIRECTION_OUTPUT) {
+		pw_stream_add_listener(impl->stream,
+				&impl->stream_listener,
+				&capture_stream_events, impl);
+	} else {
+		pw_stream_add_listener(impl->stream,
+				&impl->stream_listener,
+				&playback_stream_events, impl);
+	}
+
+	n_params = 0;
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	paramsn_params++ = spa_format_audio_raw_build(&b,
+			SPA_PARAM_EnumFormat, &impl->info);
+
+	if ((res = pw_stream_connect(impl->stream,
+			impl->direction,
+			PW_ID_ANY,
+			PW_STREAM_FLAG_AUTOCONNECT |
+			PW_STREAM_FLAG_MAP_BUFFERS |
+			PW_STREAM_FLAG_RT_PROCESS,
+			params, n_params)) < 0)
+		return res;
+
+	return 0;
+}
+
+static int create_fifo(struct impl *impl)
+{
+	struct stat st;
+	const char *filename;
+	bool do_unlink_fifo = false;
+	int fd = -1, res;
+
+	if ((filename = pw_properties_get(impl->props, "pipe.filename")) == NULL)
+		filename = impl->direction == PW_DIRECTION_INPUT ?
+			DEFAULT_CAPTURE_FILENAME :
+			DEFAULT_PLAYBACK_FILENAME;
+
+	if (mkfifo(filename, 0666) < 0) {
+		if (errno != EEXIST) {
+			res = -errno;
+			pw_log_error("mkfifo('%s'): %s", filename, spa_strerror(res));
+			goto error;
+		}
+	} else {
+		/*
+		 * Our umask is 077, so the pipe won't be created with the
+		 * requested permissions. Let's fix the permissions with chmod().
+		 */
+		if (chmod(filename, 0666) < 0)
+			pw_log_warn("chmod('%s'): %s", filename, spa_strerror(-errno));
+
+		do_unlink_fifo = true;
+	}
+
+	if ((fd = open(filename, O_RDWR | O_CLOEXEC | O_NONBLOCK, 0)) <= 0) {
+		res = -errno;
+		pw_log_error("open('%s'): %s", filename, spa_strerror(res));
+		goto error;
+	}
+
+	if (fstat(fd, &st) < 0) {
+		res = -errno;
+		pw_log_error("fstat('%s'): %s", filename, spa_strerror(res));
+		goto error;
+	}
+
+	if (!S_ISFIFO(st.st_mode)) {
+		res = -EINVAL;
+		pw_log_error("'%s' is not a FIFO.", filename);
+		goto error;
+	}
+	pw_log_info("%s fifo '%s' with format:%s channels:%d rate:%d",
+			impl->direction == PW_DIRECTION_OUTPUT ? "reading from" : "writing to",
+			filename,
+			spa_debug_type_find_name(spa_type_audio_format, impl->info.format),
+			impl->info.channels, impl->info.rate);
+
+	impl->filename = strdup(filename);
+	impl->unlink_fifo = do_unlink_fifo;
+	impl->fd = fd;
+	return 0;
+
+error:
+	if (do_unlink_fifo)
+		unlink(filename);
+	if (fd > 0)
+		close(fd);
+	return res;
+}
+
+static void core_error(void *data, uint32_t id, int seq, int res, const char *message)
+{
+	struct impl *impl = data;
+
+	pw_log_error("error id:%u seq:%d res:%d (%s): %s",
+			id, seq, res, spa_strerror(res), message);
+
+	if (id == PW_ID_CORE && res == -EPIPE)
+		pw_impl_module_schedule_destroy(impl->module);
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.error = core_error,
+};
+
+static void core_destroy(void *d)
+{
+	struct impl *impl = d;
+	spa_hook_remove(&impl->core_listener);
+	impl->core = NULL;
+	pw_impl_module_schedule_destroy(impl->module);
+}
+
+static const struct pw_proxy_events core_proxy_events = {
+	.destroy = core_destroy,
+};
+
+static void impl_destroy(struct impl *impl)
+{
+	if (impl->stream)
+		pw_stream_destroy(impl->stream);
+	if (impl->core && impl->do_disconnect)
+		pw_core_disconnect(impl->core);
+
+	if (impl->filename) {
+		if (impl->unlink_fifo)
+			unlink(impl->filename);
+		free(impl->filename);
+	}
+	if (impl->fd > 0)
+		close(impl->fd);
+
+	pw_properties_free(impl->stream_props);
+	pw_properties_free(impl->props);
+
+	free(impl->leftover);
+	free(impl);
+}
+
+static void module_destroy(void *data)
+{
+	struct impl *impl = data;
+	spa_hook_remove(&impl->module_listener);
+	impl_destroy(impl);
+}
+
+static const struct pw_impl_module_events module_events = {
+	PW_VERSION_IMPL_MODULE_EVENTS,
+	.destroy = module_destroy,
+};
+
+static uint32_t channel_from_name(const char *name)
+{
+	int i;
+	for (i = 0; spa_type_audio_channeli.name; i++) {
+		if (spa_streq(name, spa_debug_type_short_name(spa_type_audio_channeli.name)))
+			return spa_type_audio_channeli.type;
+	}
+	return SPA_AUDIO_CHANNEL_UNKNOWN;
+}
+
+static void parse_position(struct spa_audio_info_raw *info, const char *val, size_t len)
+{
+	struct spa_json it2;
+	char v256;
+
+	spa_json_init(&it0, val, len);
+        if (spa_json_enter_array(&it0, &it1) <= 0)
+                spa_json_init(&it1, val, len);
+
+	info->channels = 0;
+	while (spa_json_get_string(&it1, v, sizeof(v)) > 0 &&
+	    info->channels < SPA_AUDIO_MAX_CHANNELS) {
+		info->positioninfo->channels++ = channel_from_name(v);
+	}
+}
+
+static inline uint32_t format_from_name(const char *name, size_t len)
+{
+	int i;
+	for (i = 0; spa_type_audio_formati.name; i++) {
+		if (strncmp(name, spa_debug_type_short_name(spa_type_audio_formati.name), len) == 0)
+			return spa_type_audio_formati.type;
+	}
+	return SPA_AUDIO_FORMAT_UNKNOWN;
+}
+
+static void parse_audio_info(struct pw_properties *props, struct spa_audio_info_raw *info)
+{
+	const char *str;
+
+	*info = SPA_AUDIO_INFO_RAW_INIT(
+			.rate = 48000,
+			.channels = 2,
+			.format = SPA_AUDIO_FORMAT_S16);
+
+	if ((str = pw_properties_get(props, PW_KEY_AUDIO_FORMAT)) != NULL) {
+		uint32_t id;
+
+		id = format_from_name(str, strlen(str));
+		if (id != SPA_AUDIO_FORMAT_UNKNOWN)
+			info->format = id;
+	}
+
+	info->rate = pw_properties_get_uint32(props, PW_KEY_AUDIO_RATE, info->rate);
+	info->channels = pw_properties_get_uint32(props, PW_KEY_AUDIO_CHANNELS, info->channels);
+	if ((str = pw_properties_get(props, SPA_KEY_AUDIO_POSITION)) != NULL)
+		parse_position(info, str, strlen(str));
+
+}
+
+static int calc_frame_size(struct spa_audio_info_raw *info)
+{
+	int res = info->channels;
+	switch (info->format) {
+	case SPA_AUDIO_FORMAT_U8:
+	case SPA_AUDIO_FORMAT_S8:
+	case SPA_AUDIO_FORMAT_ALAW:
+	case SPA_AUDIO_FORMAT_ULAW:
+		return res;
+	case SPA_AUDIO_FORMAT_S16:
+	case SPA_AUDIO_FORMAT_S16_OE:
+	case SPA_AUDIO_FORMAT_U16:
+		return res * 2;
+	case SPA_AUDIO_FORMAT_S24:
+	case SPA_AUDIO_FORMAT_S24_OE:
+	case SPA_AUDIO_FORMAT_U24:
+		return res * 3;
+	case SPA_AUDIO_FORMAT_S24_32:
+	case SPA_AUDIO_FORMAT_S24_32_OE:
+	case SPA_AUDIO_FORMAT_S32:
+	case SPA_AUDIO_FORMAT_S32_OE:
+	case SPA_AUDIO_FORMAT_U32:
+	case SPA_AUDIO_FORMAT_U32_OE:
+	case SPA_AUDIO_FORMAT_F32:
+	case SPA_AUDIO_FORMAT_F32_OE:
+		return res * 4;
+	case SPA_AUDIO_FORMAT_F64:
+	case SPA_AUDIO_FORMAT_F64_OE:
+		return res * 8;
+	default:
+		return 0;
+	}
+}
+
+static void copy_props(struct impl *impl, struct pw_properties *props, const char *key)
+{
+	const char *str;
+	if ((str = pw_properties_get(props, key)) != NULL) {
+		if (pw_properties_get(impl->stream_props, key) == NULL)
+			pw_properties_set(impl->stream_props, key, str);
+	}
+}
+
+SPA_EXPORT
+int pipewire__module_init(struct pw_impl_module *module, const char *args)
+{
+	struct pw_context *context = pw_impl_module_get_context(module);
+	struct pw_properties *props = NULL;
+	struct impl *impl;
+	const char *str, *media_class = NULL;
+	int res;
+
+	PW_LOG_TOPIC_INIT(mod_topic);
+
+	impl = calloc(1, sizeof(struct impl));
+	if (impl == NULL)
+		return -errno;
+
+	impl->fd = -1;
+
+	pw_log_debug("module %p: new %s", impl, args);
+
+	if (args == NULL)
+		args = "";
+
+	props = pw_properties_new_string(args);
+	if (props == NULL) {
+		res = -errno;
+		pw_log_error( "can't create properties: %m");
+		goto error;
+	}
+	impl->props = props;
+
+	impl->stream_props = pw_properties_new(NULL, NULL);
+	if (impl->stream_props == NULL) {
+		res = -errno;
+		pw_log_error( "can't create properties: %m");
+		goto error;
+	}
+
+	impl->module = module;
+	impl->context = context;
+
+	if ((str = pw_properties_get(props, "tunnel.mode")) == NULL)
+		str = "playback";
+
+	if (spa_streq(str, "capture")) {
+		impl->mode = MODE_CAPTURE;
+		impl->direction = PW_DIRECTION_INPUT;
+	} else if (spa_streq(str, "playback")) {
+		impl->mode = MODE_PLAYBACK;
+		impl->direction = PW_DIRECTION_OUTPUT;
+	}else if (spa_streq(str, "sink")) {
+		impl->mode = MODE_SINK;
+		impl->direction = PW_DIRECTION_INPUT;
+		media_class = "Audio/Sink";
+	} else if (spa_streq(str, "source")) {
+		impl->mode = MODE_SOURCE;
+		impl->direction = PW_DIRECTION_OUTPUT;
+		media_class = "Audio/Source";
+	} else {
+		pw_log_error("invalid tunnel.mode '%s'", str);
+		res = -EINVAL;
+		goto error;
+	}
+
+	if (pw_properties_get(props, PW_KEY_NODE_VIRTUAL) == NULL)
+		pw_properties_set(props, PW_KEY_NODE_VIRTUAL, "true");
+	if (pw_properties_get(props, PW_KEY_MEDIA_CLASS) == NULL)
+		pw_properties_set(props, PW_KEY_MEDIA_CLASS, media_class);
+
+	if ((str = pw_properties_get(props, "stream.props")) != NULL)
+		pw_properties_update_string(impl->stream_props, str, strlen(str));
+
+	copy_props(impl, props, PW_KEY_AUDIO_FORMAT);
+	copy_props(impl, props, PW_KEY_AUDIO_RATE);
+	copy_props(impl, props, PW_KEY_AUDIO_CHANNELS);
+	copy_props(impl, props, SPA_KEY_AUDIO_POSITION);
+	copy_props(impl, props, PW_KEY_NODE_NAME);
+	copy_props(impl, props, PW_KEY_NODE_DESCRIPTION);
+	copy_props(impl, props, PW_KEY_NODE_GROUP);
+	copy_props(impl, props, PW_KEY_NODE_LATENCY);
+	copy_props(impl, props, PW_KEY_NODE_VIRTUAL);
+	copy_props(impl, props, PW_KEY_MEDIA_CLASS);
+
+	parse_audio_info(impl->stream_props, &impl->info);
+
+	if (impl->info.rate != 0 &&
+	    pw_properties_get(props, PW_KEY_NODE_RATE) == NULL)
+		pw_properties_setf(props, PW_KEY_NODE_RATE,
+				"1/%u", impl->info.rate),
+
+	copy_props(impl, props, PW_KEY_NODE_RATE);
+
+	impl->frame_size = calc_frame_size(&impl->info);
+	if (impl->frame_size == 0) {
+		pw_log_error("unsupported audio format:%d channels:%d",
+				impl->info.format, impl->info.channels);
+		res = -EINVAL;
+		goto error;
+	}
+	impl->leftover = calloc(1, impl->frame_size);
+	if (impl->leftover == NULL) {
+		res = -errno;
+		pw_log_error("can't alloc leftover buffer: %m");
+		goto error;
+	}
+
+	impl->core = pw_context_get_object(impl->context, PW_TYPE_INTERFACE_Core);
+	if (impl->core == NULL) {
+		str = pw_properties_get(props, PW_KEY_REMOTE_NAME);
+		impl->core = pw_context_connect(impl->context,
+				pw_properties_new(
+					PW_KEY_REMOTE_NAME, str,
+					NULL),
+				0);
+		impl->do_disconnect = true;
+	}
+	if (impl->core == NULL) {
+		res = -errno;
+		pw_log_error("can't connect: %m");
+		goto error;
+	}
+
+	pw_proxy_add_listener((struct pw_proxy*)impl->core,
+			&impl->core_proxy_listener,
+			&core_proxy_events, impl);
+	pw_core_add_listener(impl->core,
+			&impl->core_listener,
+			&core_events, impl);
+
+	if ((res = create_fifo(impl)) < 0)
+		goto error;
+
+	if ((res = create_stream(impl)) < 0)
+		goto error;
+
+	pw_impl_module_add_listener(module, &impl->module_listener, &module_events, impl);
+
+	pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
+
+	return 0;
+
+error:
+	impl_destroy(impl);
+	return res;
+}

pipewire-0.3.51.tar.gz/src/modules/module-profiler.c -> pipewire-0.3.52.tar.gz/src/modules/module-profiler.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-protocol-native.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-native.c Changed

@@ -347,9 +347,12 @@
 			continue;
 		}
 
+		resource->refcount++;
 		pw_protocol_native_connection_enter(conn);
 		res = demarshalmsg->opcode.func(resource, msg);
 		pw_protocol_native_connection_leave(conn);
+		pw_resource_unref(resource);
+
 		if (res < 0) {
 			pw_resource_errorf_id(resource, msg->id,
 					res, "invalid message id:%u op:%u (%s)",
@@ -360,6 +363,7 @@
 	res = 0;
 done:
 	context->current_client = NULL;
+
 	return res;
 
 error:
@@ -387,14 +391,15 @@
 		pw_loop_signal_event(s->loop, s->resume);
 }
 
-static void handle_client_error(struct pw_impl_client *client, int res)
+static void handle_client_error(struct pw_impl_client *client, int res, const char *msg)
 {
 	if (res == -EPIPE || res == -ECONNRESET)
-		pw_log_info("%p: client %p disconnected", client->protocol, client);
+		pw_log_info("%p: %s: client %p disconnected", client->protocol, msg, client);
 	else
-		pw_log_error("%p: client %p error %d (%s)", client->protocol,
+		pw_log_error("%p: %s: client %p error %d (%s)", client->protocol, msg,
 				client, res, spa_strerror(res));
-	pw_impl_client_destroy(client);
+	if (!client->destroyed)
+		pw_impl_client_destroy(client);
 }
 
 static void
@@ -404,6 +409,8 @@
 	struct pw_impl_client *client = this->client;
 	int res;
 
+	client->refcount++;
+
 	if (mask & SPA_IO_HUP) {
 		res = -EPIPE;
 		goto error;
@@ -425,9 +432,19 @@
 		} else if (res != -EAGAIN)
 			goto error;
 	}
+done:
+	pw_impl_client_unref(client);
 	return;
 error:
-	handle_client_error(client, res);
+	handle_client_error(client, res, "connection_data");
+	goto done;
+}
+
+static void client_destroy(void *data)
+{
+	struct client_data *this = data;
+	pw_log_debug("%p: destroy", this);
+	spa_list_remove(&this->protocol_link);
 }
 
 static void client_free(void *data)
@@ -436,8 +453,6 @@
 	struct pw_impl_client *client = this->client;
 
 	pw_log_debug("%p: free", this);
-	spa_list_remove(&this->protocol_link);
-
 	spa_hook_remove(&this->client_listener);
 
 	if (this->source)
@@ -450,6 +465,7 @@
 
 static const struct pw_impl_client_events client_events = {
 	PW_VERSION_IMPL_CLIENT_EVENTS,
+	.destroy = client_destroy,
 	.free = client_free,
 	.busy_changed = client_busy_changed,
 };
@@ -1215,12 +1231,12 @@
 	pw_log_debug("flush");
 
 	spa_list_for_each_safe(data, tmp, &this->client_list, protocol_link) {
+		data->client->refcount++;
 		if ((res = process_messages(data)) < 0)
-			goto error;
+			handle_client_error(data->client, res, "do_resume");
+		pw_impl_client_unref(data->client);
 	}
 	return;
-error:
-	handle_client_error(data->client, res);
 }
 
 static const char *

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/collect.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/collect.c Changed

@@ -112,29 +112,41 @@
 	return false;
 }
 
+struct pw_manager_object *find_peer_for_link(struct pw_manager *m,
+		struct pw_manager_object *o, uint32_t id, enum pw_direction direction)
+{
+	struct pw_manager_object *p;
+	uint32_t in_node, out_node;
+
+	if (o->props == NULL)
+		return NULL;
+
+	if (pw_properties_fetch_uint32(o->props, PW_KEY_LINK_OUTPUT_NODE, &out_node) != 0 ||
+	    pw_properties_fetch_uint32(o->props, PW_KEY_LINK_INPUT_NODE, &in_node) != 0)
+		return NULL;
+
+	if (direction == PW_DIRECTION_OUTPUT && id == out_node) {
+		struct selector sel = { .id = in_node, .type = pw_manager_object_is_sink, };
+		if ((p = select_object(m, &sel)) != NULL)
+			return p;
+	}
+	if (direction == PW_DIRECTION_INPUT && id == in_node) {
+		struct selector sel = { .id = out_node, .type = pw_manager_object_is_recordable, };
+		if ((p = select_object(m, &sel)) != NULL)
+			return p;
+	}
+	return NULL;
+}
+
 struct pw_manager_object *find_linked(struct pw_manager *m, uint32_t id, enum pw_direction direction)
 {
 	struct pw_manager_object *o, *p;
-	uint32_t in_node, out_node;
 
 	spa_list_for_each(o, &m->object_list, link) {
-		if (o->props == NULL || !pw_manager_object_is_link(o))
+		if (!pw_manager_object_is_link(o))
 			continue;
-
-		if (pw_properties_fetch_uint32(o->props, PW_KEY_LINK_OUTPUT_NODE, &out_node) != 0 ||
-                    pw_properties_fetch_uint32(o->props, PW_KEY_LINK_INPUT_NODE, &in_node) != 0)
-                        continue;
-
-		if (direction == PW_DIRECTION_OUTPUT && id == out_node) {
-			struct selector sel = { .id = in_node, .type = pw_manager_object_is_sink, };
-			if ((p = select_object(m, &sel)) != NULL)
-				return p;
-		}
-		if (direction == PW_DIRECTION_INPUT && id == in_node) {
-			struct selector sel = { .id = out_node, .type = pw_manager_object_is_recordable, };
-			if ((p = select_object(m, &sel)) != NULL)
-				return p;
-		}
+		if ((p = find_peer_for_link(m, o, id, direction)) != NULL)
+			return p;
 	}
 	return NULL;
 }

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/collect.h -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/collect.h Changed

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/format.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/format.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/manager.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/manager.c Changed

@@ -41,12 +41,15 @@
 #define manager_emit_removed(m,o) spa_hook_list_call(&m->hooks, struct pw_manager_events, removed, 0, o)
 #define manager_emit_metadata(m,o,s,k,t,v) spa_hook_list_call(&m->hooks, struct pw_manager_events, metadata,0,o,s,k,t,v)
 #define manager_emit_disconnect(m) spa_hook_list_call(&m->hooks, struct pw_manager_events, disconnect, 0)
+#define manager_emit_object_data_timeout(m,o,k) spa_hook_list_call(&m->hooks, struct pw_manager_events, object_data_timeout,0,o,k)
 
 struct object;
 
 struct manager {
 	struct pw_manager this;
 
+	struct pw_loop *loop;
+
 	struct spa_hook core_listener;
 	struct spa_hook registry_listener;
 	int sync_seq;
@@ -64,8 +67,10 @@
 
 struct object_data {
 	struct spa_list link;
+	struct object *object;
 	const char *key;
 	size_t size;
+	struct spa_source *timer;
 };
 
 struct object {
@@ -188,6 +193,16 @@
 	}
 }
 
+static void object_data_free(struct object_data *d)
+{
+	spa_list_remove(&d->link);
+	if (d->timer) {
+		pw_loop_destroy_source(d->object->manager->loop, d->timer);
+		d->timer = NULL;
+	}
+	free(d);
+}
+
 static void object_destroy(struct object *o)
 {
 	struct manager *m = o->manager;
@@ -201,10 +216,8 @@
 		free(o->this.message_object_path);
 	clear_params(&o->this.param_list, SPA_ID_INVALID);
 	clear_params(&o->pending_list, SPA_ID_INVALID);
-	spa_list_consume(d, &o->data_list, link) {
-		spa_list_remove(&d->link);
-		free(d);
-	}
+	spa_list_consume(d, &o->data_list, link)
+		object_data_free(d);
 	free(o);
 }
 
@@ -716,6 +729,7 @@
 struct pw_manager *pw_manager_new(struct pw_core *core)
 {
 	struct manager *m;
+	struct pw_context *context;
 
 	m = calloc(1, sizeof(*m));
 	if (m == NULL)
@@ -729,6 +743,9 @@
 		return NULL;
 	}
 
+	context = pw_core_get_context(core);
+	m->loop = pw_context_get_main_loop(context);
+
 	spa_hook_list_init(&m->hooks);
 
 	spa_list_init(&m->this.object_list);
@@ -847,11 +864,14 @@
 	if (d != NULL) {
 		if (d->size == size)
 			goto done;
-		spa_list_remove(&d->link);
-		free(d);
+		object_data_free(d);
 	}
 
 	d = calloc(1, sizeof(struct object_data) + size);
+	if (d == NULL)
+		return NULL;
+
+	d->object = o;
 	d->key = key;
 	d->size = size;
 
@@ -861,6 +881,49 @@
 	return SPA_PTROFF(d, sizeof(struct object_data), void);
 }
 
+static void object_data_timeout(void *data, uint64_t count)
+{
+	struct object_data *d = data;
+	struct object *o = d->object;
+	struct manager *m = o->manager;
+
+	pw_log_debug("manager:%p object id:%d data '%s' lifetime ends",
+			m, o->this.id, d->key);
+
+	if (d->timer) {
+		pw_loop_destroy_source(m->loop, d->timer);
+		d->timer = NULL;
+	}
+
+	manager_emit_object_data_timeout(m, &o->this, d->key);
+}
+
+void *pw_manager_object_add_temporary_data(struct pw_manager_object *obj, const char *key,
+		size_t size, uint64_t lifetime_nsec)
+{
+	struct object *o = SPA_CONTAINER_OF(obj, struct object, this);
+	struct object_data *d;
+	void *data;
+	struct timespec timeout = {0}, interval = {0};
+
+	data = pw_manager_object_add_data(obj, key, size);
+	if (data == NULL)
+		return NULL;
+
+	d = SPA_PTROFF(data, -sizeof(struct object_data), void);
+
+	if (d->timer == NULL)
+		d->timer = pw_loop_add_timer(o->manager->loop, object_data_timeout, d);
+	if (d->timer == NULL)
+		return NULL;
+
+	timeout.tv_sec = lifetime_nsec / SPA_NSEC_PER_SEC;
+	timeout.tv_nsec = lifetime_nsec % SPA_NSEC_PER_SEC;
+	pw_loop_update_timer(o->manager->loop, d->timer, &timeout, &interval, false);
+
+	return data;
+}
+
 void *pw_manager_object_get_data(struct pw_manager_object *obj, const char *id)
 {
 	struct object *o = SPA_CONTAINER_OF(obj, struct object, this);

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/manager.h -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/manager.h Changed

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/message.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/message.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/module.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/module.c Changed

@@ -59,16 +59,17 @@
 	module->unloading = true;
 }
 
-struct module *module_new(struct impl *impl, size_t user_data)
+static struct module *module_new(struct impl *impl, const struct module_info *info)
 {
 	struct module *module;
 
-	module = calloc(1, sizeof(struct module) + user_data);
+	module = calloc(1, sizeof(*module) + info->data_size);
 	if (module == NULL)
 		return NULL;
 
 	module->index = SPA_ID_INVALID;
 	module->impl = impl;
+	module->info = info;
 	spa_hook_list_init(&module->listener_list);
 	module->user_data = SPA_PTROFF(module, sizeof(*module), void);
 	module->loaded = false;
@@ -304,17 +305,34 @@
 		}
 	}
 
-	module = info->create(impl, args);
+	module = module_new(impl, info);
 	if (module == NULL)
 		return NULL;
 
-	module->info = info;
+	module->props = pw_properties_new(NULL, NULL);
+	if (module->props == NULL) {
+		module_free(module);
+		return NULL;
+	}
+
+	if (args)
+		module_args_add_props(module->props, args);
+
+	int res = module->info->prepare(module);
+	if (res < 0) {
+		module_free(module);
+		errno = -res;
+		return NULL;
+	}
+
 	module->index = pw_map_insert_new(&impl->modules, module);
 	if (module->index == SPA_ID_INVALID) {
 		module_unload(module);
 		return NULL;
 	}
+
 	module->args = args ? strdup(args) : NULL;
 	module->index |= MODULE_FLAG;
+
 	return module;
 }

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/module.h -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/module.h Changed

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-always-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-always-sink.c Changed

@@ -101,40 +101,22 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_always_sink(struct impl *impl, const char *argument)
+static int module_always_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct pw_properties *props = NULL;
-	int res;
-
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_always_sink_info));
-	if (props == NULL) {
-		res = -EINVAL;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
-
-	module = module_new(impl, sizeof(struct module_always_sink_data));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-	module->props = props;
+	struct module_always_sink_data * const data = module->user_data;
+	data->module = module;
 
-	return module;
-out:
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
+	return 0;
 }
 
 DEFINE_MODULE_INFO(module_always_sink) = {
 	.name = "module-always-sink",
 	.load_once = true,
-	.create = create_module_always_sink,
+	.prepare = module_always_sink_prepare,
 	.load = module_always_sink_load,
 	.unload = module_always_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_always_sink_info),
+	.data_size = sizeof(struct module_always_sink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-combine-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-combine-sink.c Changed

@@ -124,8 +124,7 @@
 
 	for (i = 0; i < MAX_SINKS; i++) {
 		struct pw_buffer *out;
-		uint32_t j, size = 0;
-		int32_t stride = 0;
+		uint32_t j;
 
 		if (data->streamsi.stream == NULL || data->streamsi.cleanup)
 			continue;
@@ -142,23 +141,29 @@
 
 		for (j = 0; j < out->buffer->n_datas; j++) {
 			struct spa_data *ds, *dd;
+			uint32_t outsize = 0;
+			int32_t stride = 0;
 
 			dd = &out->buffer->datasj;
 
 			if (j < in->buffer->n_datas) {
+				uint32_t offs, size;
+
 				ds = &in->buffer->datasj;
 
+				offs = SPA_MIN(ds->chunk->offset, ds->maxsize);
+				size = SPA_MIN(ds->chunk->size, ds->maxsize - offs);
+
 				memcpy(dd->data,
-					SPA_PTROFF(ds->data, ds->chunk->offset, void),
-					ds->chunk->size);
+					SPA_PTROFF(ds->data, offs, void), size);
 
-				size = SPA_MAX(size, ds->chunk->size);
+				outsize = SPA_MAX(outsize, size);
 				stride = SPA_MAX(stride, ds->chunk->stride);
 			} else {
-				memset(dd->data, 0, size);
+				memset(dd->data, 0, outsize);
 			}
 			dd->chunk->offset = 0;
-			dd->chunk->size = size;
+			dd->chunk->size = outsize;
 			dd->chunk->stride = stride;
 		}
 
@@ -499,11 +504,10 @@
 	return 0;
 }
 
-struct module *create_module_combine_sink(struct impl *impl, const char *argument)
+static int module_combine_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_combine_sink_data *d;
-	struct pw_properties *props = NULL;
+	struct module_combine_sink_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
 	const char *str;
 	char *sink_name = NULL, **sink_names = NULL;
 	struct spa_audio_info_raw info = { 0 };
@@ -512,14 +516,6 @@
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_combine_sink_info));
-	if (!props) {
-		res = -EINVAL;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
-
 	if ((str = pw_properties_get(props, "sink_name")) != NULL) {
 		sink_name = strdup(str);
 		pw_properties_set(props, "sink_name", NULL);
@@ -542,19 +538,11 @@
 		pw_properties_set(props, "resample_method", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->info = info;
 	d->sink_name = sink_name;
@@ -565,18 +553,19 @@
 		d->streamsi.cleanup = false;
 	}
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	free(sink_name);
 	pw_free_strv(sink_names);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_combine_sink) = {
 	.name = "module-combine-sink",
-	.create = create_module_combine_sink,
+	.prepare = module_combine_sink_prepare,
 	.load = module_combine_sink_load,
 	.unload = module_combine_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_combine_sink_info),
+	.data_size = sizeof(struct module_combine_sink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-echo-cancel.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-echo-cancel.c Changed

@@ -155,27 +155,24 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_echo_cancel(struct impl *impl, const char *argument)
+static int module_echo_cancel_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_echo_cancel_data *d;
-	struct pw_properties *props = NULL, *aec_props = NULL, *sink_props = NULL, *source_props = NULL;
+	struct module_echo_cancel_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *aec_props = NULL, *sink_props = NULL, *source_props = NULL;
 	const char *str;
 	struct spa_audio_info_raw info = { 0 };
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_echo_cancel_info));
 	aec_props = pw_properties_new(NULL, NULL);
 	source_props = pw_properties_new(NULL, NULL);
 	sink_props = pw_properties_new(NULL, NULL);
-	if (!props ||!aec_props || !source_props || !sink_props) {
+	if (!aec_props || !source_props || !sink_props) {
 		res = -EINVAL;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	if ((str = pw_properties_get(props, "source_name")) != NULL) {
 		pw_properties_set(source_props, PW_KEY_NODE_NAME, str);
@@ -208,7 +205,7 @@
 		pw_properties_set(props, "sink_master", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -233,34 +230,26 @@
 		pw_properties_set(props, "aec_args", NULL);
 	}
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->props = aec_props;
 	d->source_props = source_props;
 	d->sink_props = sink_props;
 	d->info = info;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(aec_props);
 	pw_properties_free(sink_props);
 	pw_properties_free(source_props);
-	errno = -res;
 
-	return NULL;
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_echo_cancel) = {
 	.name = "module-echo-cancel",
-	.create = create_module_echo_cancel,
+	.prepare = module_echo_cancel_prepare,
 	.load = module_echo_cancel_load,
 	.unload = module_echo_cancel_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_echo_cancel_info),
+	.data_size = sizeof(struct module_echo_cancel_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-ladspa-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-ladspa-sink.c Changed

@@ -177,11 +177,11 @@
 	pw_properties_set(props, SPA_KEY_AUDIO_POSITION, s);
 }
 
-struct module *create_module_ladspa_sink(struct impl *impl, const char *argument)
+static int module_ladspa_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_ladspa_sink_data *d;
-	struct pw_properties *props = NULL, *playback_props = NULL, *capture_props = NULL;
+	struct module_ladspa_sink_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *playback_props = NULL, *capture_props = NULL;
 	const char *str;
 	struct spa_audio_info_raw capture_info = { 0 };
 	struct spa_audio_info_raw playback_info = { 0 };
@@ -189,15 +189,12 @@
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_ladspa_sink_info));
 	capture_props = pw_properties_new(NULL, NULL);
 	playback_props = pw_properties_new(NULL, NULL);
-	if (!props || !capture_props || !playback_props) {
+	if (!capture_props || !playback_props) {
 		res = -EINVAL;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	if ((str = pw_properties_get(props, "sink_name")) != NULL) {
 		pw_properties_set(capture_props, PW_KEY_NODE_NAME, str);
@@ -226,7 +223,7 @@
 		pw_properties_set(props, "master", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &capture_info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &capture_info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -238,30 +235,23 @@
 	if (pw_properties_get(playback_props, PW_KEY_NODE_PASSIVE) == NULL)
 		pw_properties_set(playback_props, PW_KEY_NODE_PASSIVE, "true");
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->capture_props = capture_props;
 	d->playback_props = playback_props;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(playback_props);
 	pw_properties_free(capture_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_ladspa_sink) = {
 	.name = "module-ladspa-sink",
-	.create = create_module_ladspa_sink,
+	.prepare = module_ladspa_sink_prepare,
 	.load = module_ladspa_sink_load,
 	.unload = module_ladspa_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_ladspa_sink_info),
+	.data_size = sizeof(struct module_ladspa_sink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-ladspa-source.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-ladspa-source.c Changed

@@ -177,11 +177,11 @@
 	pw_properties_set(props, SPA_KEY_AUDIO_POSITION, s);
 }
 
-struct module *create_module_ladspa_source(struct impl *impl, const char *argument)
+static int module_ladspa_source_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_ladspa_source_data *d;
-	struct pw_properties *props = NULL, *playback_props = NULL, *capture_props = NULL;
+	struct module_ladspa_source_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *playback_props = NULL, *capture_props = NULL;
 	const char *str;
 	struct spa_audio_info_raw capture_info = { 0 };
 	struct spa_audio_info_raw playback_info = { 0 };
@@ -189,15 +189,12 @@
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_ladspa_source_info));
 	capture_props = pw_properties_new(NULL, NULL);
 	playback_props = pw_properties_new(NULL, NULL);
-	if (!props || !capture_props || !playback_props) {
+	if (!capture_props || !playback_props) {
 		res = -EINVAL;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	if ((str = pw_properties_get(props, "source_name")) != NULL) {
 		pw_properties_set(playback_props, PW_KEY_NODE_NAME, str);
@@ -226,7 +223,7 @@
 		pw_properties_set(props, "master", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &playback_info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &playback_info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -238,30 +235,23 @@
 	if (pw_properties_get(capture_props, PW_KEY_NODE_PASSIVE) == NULL)
 		pw_properties_set(capture_props, PW_KEY_NODE_PASSIVE, "true");
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->capture_props = capture_props;
 	d->playback_props = playback_props;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(playback_props);
 	pw_properties_free(capture_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_ladspa_source) = {
 	.name = "module-ladspa-source",
-	.create = create_module_ladspa_source,
+	.prepare = module_ladspa_source_prepare,
 	.load = module_ladspa_source_load,
 	.unload = module_ladspa_source_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_ladspa_source_info),
+	.data_size = sizeof(struct module_ladspa_source_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-loopback.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-loopback.c Changed

@@ -143,26 +143,23 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_loopback(struct impl *impl, const char *argument)
+static int module_loopback_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_loopback_data *d;
-	struct pw_properties *props = NULL, *playback_props = NULL, *capture_props = NULL;
+	struct module_loopback_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *playback_props = NULL, *capture_props = NULL;
 	const char *str;
 	struct spa_audio_info_raw info = { 0 };
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_loopback_info));
 	capture_props = pw_properties_new(NULL, NULL);
 	playback_props = pw_properties_new(NULL, NULL);
-	if (!props || !capture_props || !playback_props) {
+	if (!capture_props || !playback_props) {
 		res = -EINVAL;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	/* The following modargs are not implemented:
 	 * adjust_time, max_latency_msec, fast_adjust_threshold_msec: these are just not relevant
@@ -185,7 +182,7 @@
 		pw_properties_set(props, "sink", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -227,32 +224,24 @@
 		pw_properties_set(props, "source_output_properties", NULL);
 	}
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->capture_props = capture_props;
 	d->playback_props = playback_props;
 	d->info = info;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(playback_props);
 	pw_properties_free(capture_props);
-	errno = -res;
 
-	return NULL;
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_loopback) = {
 	.name = "module-loopback",
-	.create = create_module_loopback,
+	.prepare = module_loopback_prepare,
 	.load = module_loopback_load,
 	.unload = module_loopback_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_loopback_info),
+	.data_size = sizeof(struct module_loopback_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-native-protocol-tcp.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-native-protocol-tcp.c Changed

@@ -74,56 +74,54 @@
 	{ PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
 	{ PW_KEY_MODULE_DESCRIPTION, "Native protocol (TCP sockets)" },
 	{ PW_KEY_MODULE_USAGE, "port=<TCP port number> "
-				"listen=<address to listen on>" },
+				"listen=<address to listen on> "
+				"auth-anonymous=<don't check for cookies?>"},
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_native_protocol_tcp(struct impl *impl, const char *argument)
+static int module_native_protocol_tcp_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_native_protocol_tcp_data *d;
-	struct pw_properties *props = NULL;
-	const char *port, *listen;
-	int res;
+	struct module_native_protocol_tcp_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	const char *port, *listen, *auth;
+	FILE *f;
+	char *args;
+	size_t size;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_native_protocol_tcp_info));
-	if (props == NULL) {
-		res = -errno;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
-
 	if ((port = pw_properties_get(props, "port")) == NULL)
 		port = SPA_STRINGIFY(PW_PROTOCOL_PULSE_DEFAULT_PORT);
 
 	listen = pw_properties_get(props, "listen");
 
-	pw_properties_setf(props, "pulse.tcp", " \"tcp:%s%s%s\" ",
+	auth = pw_properties_get(props, "auth-anonymous");
+
+	f = open_memstream(&args, &size);
+	if (f == NULL)
+		return -errno;
+
+	fprintf(f, " { ");
+	fprintf(f, " \"address\": \"tcp:%s%s%s\" ",
 			   listen ? listen : "", listen ? ":" : "", port);
+	if (auth && module_args_parse_bool(auth))
+		fprintf(f, " \"client.access\": \"unrestricted\" ");
+	fprintf(f, "} ");
+	fclose(f);
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
+	pw_properties_set(props, "pulse.tcp", args);
+	free(args);
 
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 
-	return module;
-out:
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
+	return 0;
 }
 
 DEFINE_MODULE_INFO(module_native_protocol_tcp) = {
 	.name = "module-native-protocol-tcp",
-	.create = create_module_native_protocol_tcp,
+	.prepare = module_native_protocol_tcp_prepare,
 	.load = module_native_protocol_tcp_load,
 	.unload = module_native_protocol_tcp_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_native_protocol_tcp_info),
+	.data_size = sizeof(struct module_native_protocol_tcp_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-null-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-null-sink.c Changed

@@ -158,25 +158,15 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_null_sink(struct impl *impl, const char *argument)
+static int module_null_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct pw_properties *props = NULL;
+	struct pw_properties * const props = module->props;
 	const char *str;
 	struct spa_audio_info_raw info = { 0 };
 	uint32_t i;
-	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_null_sink_info));
-	if (props == NULL) {
-		res = -EINVAL;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
-
 	if ((str = pw_properties_get(props, "sink_name")) != NULL) {
 		pw_properties_set(props, PW_KEY_NODE_NAME, str);
 		pw_properties_set(props, "sink_name", NULL);
@@ -190,10 +180,8 @@
 		pw_properties_set(props, "sink_properties", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
-		res = -EINVAL;
-		goto out;
-	}
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0)
+		return -EINVAL;
 
 	if (info.rate)
 		pw_properties_setf(props, SPA_KEY_AUDIO_RATE, "%u", info.rate);
@@ -227,23 +215,14 @@
 	if (pw_properties_get(props, "monitor.channel-volumes") == NULL)
 		pw_properties_set(props, "monitor.channel-volumes", "true");
 
-	module = module_new(impl, sizeof(struct module_null_sink_data));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-	module->props = props;
-
-	return module;
-out:
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
+	return 0;
 }
 
 DEFINE_MODULE_INFO(module_null_sink) = {
 	.name = "module-null-sink",
-	.create = create_module_null_sink,
+	.prepare = module_null_sink_prepare,
 	.load = module_null_sink_load,
 	.unload = module_null_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_null_sink_info),
+	.data_size = sizeof(struct module_null_sink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-pipe-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-pipe-sink.c Changed

@@ -40,149 +40,78 @@
 PW_LOG_TOPIC_STATIC(mod_topic, "mod." NAME);
 #define PW_LOG_TOPIC_DEFAULT mod_topic
 
-#define DEFAULT_FILE_NAME "/tmp/music.output"
-
 struct module_pipesink_data {
 	struct module *module;
-	struct pw_core *core;
-
-	struct pw_stream *capture;
 
-	struct spa_hook core_listener;
-	struct spa_hook capture_listener;
+	struct spa_hook mod_listener;
+	struct pw_impl_module *mod;
 
 	struct pw_properties *capture_props;
-
 	struct spa_audio_info_raw info;
-
 	char *filename;
-	int fd;
-	bool do_unlink_fifo;
-};
-
-static void capture_process(void *data)
-{
-	struct module_pipesink_data *impl = data;
-	struct pw_buffer *in;
-	struct spa_data *d;
-	uint32_t i, size, offset;
-	int written;
-
-	if ((in = pw_stream_dequeue_buffer(impl->capture)) == NULL) {
-		pw_log_warn("Out of capture buffers: %m");
-		return;
-	}
-
-	for (i = 0; i < in->buffer->n_datas; i++) {
-		d = &in->buffer->datasi;
-		size = d->chunk->size;
-		offset = d->chunk->offset;
-
-		while (size > 0) {
-			written = write(impl->fd, SPA_MEMBER(d->data, offset, void), size);
-			if (written < 0) {
-				if (errno == EINTR) {
-					/* retry if interrupted */
-					continue;
-				} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
-					/* Don't continue writing */
-					break;
-				} else {
-					pw_log_warn("Failed to write to pipe sink");
-				}
-			}
-
-			offset += written;
-			size -= written;
-		}
-	}
-	pw_stream_queue_buffer(impl->capture, in);
-}
-
-static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
-{
-	struct module_pipesink_data *d = data;
-
-	pw_log_error("error id:%u seq:%d res:%d (%s): %s",
-			id, seq, res, spa_strerror(res), message);
-
-	if (id == PW_ID_CORE && res == -EPIPE)
-		module_schedule_unload(d->module);
-}
-
-static const struct pw_core_events core_events = {
-	PW_VERSION_CORE_EVENTS,
-	.error = on_core_error,
 };
 
-static void on_stream_state_changed(void *data, enum pw_stream_state old,
-		enum pw_stream_state state, const char *error)
+static void module_destroy(void *data)
 {
 	struct module_pipesink_data *d = data;
-
-	switch (state) {
-		case PW_STREAM_STATE_UNCONNECTED:
-			pw_log_info("stream disconnected, unloading");
-			module_schedule_unload(d->module);
-			break;
-		case PW_STREAM_STATE_ERROR:
-			pw_log_error("stream error: %s", error);
-			break;
-		default:
-			break;
-	}
+	spa_hook_remove(&d->mod_listener);
+	d->mod = NULL;
+	module_schedule_unload(d->module);
 }
 
-static const struct pw_stream_events in_stream_events = {
-	PW_VERSION_STREAM_EVENTS,
-	.state_changed = on_stream_state_changed,
-	.process = capture_process
+static const struct pw_impl_module_events module_events = {
+	PW_VERSION_IMPL_MODULE_EVENTS,
+	.destroy = module_destroy
 };
 
 static int module_pipe_sink_load(struct client *client, struct module *module)
 {
 	struct module_pipesink_data *data = module->user_data;
-	int res;
-	uint32_t n_params;
-	const struct spa_pod *params1;
-	uint8_t buffer1024;
-	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+	FILE *f;
+	char *args;
+	size_t size;
+	uint32_t i;
 
-	data->core = pw_context_connect(module->impl->context,
-			pw_properties_copy(client->props),
-			0);
-	if (data->core == NULL)
-		return -errno;
+	pw_properties_setf(data->capture_props, "pulse.module.id",
+			"%u", module->index);
 
-	pw_core_add_listener(data->core,
-			&data->core_listener,
-			&core_events, data);
-
-	pw_properties_setf(data->capture_props, "pulse.module.id", "%u", module->index);
-
-	data->capture = pw_stream_new(data->core,
-			"pipesink capture", data->capture_props);
-	data->capture_props = NULL;
-	if (data->capture == NULL)
+	if ((f = open_memstream(&args, &size)) == NULL)
 		return -errno;
 
-	pw_stream_add_listener(data->capture,
-			&data->capture_listener,
-			&in_stream_events, data);
+	fprintf(f, "{");
+	fprintf(f, " \"tunnel.mode\" = \"sink\" ");
+	if (data->filename != NULL)
+		fprintf(f, " \"pipe.filename\": \"%s\"", data->filename);
+	if (data->info.format != 0)
+		fprintf(f, " \"audio.format\": \"%s\"", format_id2name(data->info.format));
+	if (data->info.rate != 0)
+		fprintf(f, " \"audio.rate\": %u,", data->info.rate);
+	if (data->info.channels != 0) {
+		fprintf(f, " \"audio.channels\": %u,", data->info.channels);
+		if (!(data->info.flags & SPA_AUDIO_FLAG_UNPOSITIONED)) {
+			fprintf(f, " \"audio.position\":  ");
+			for (i = 0; i < data->info.channels; i++)
+				fprintf(f, "%s\"%s\"", i == 0 ? "" : ",",
+					channel_id2name(data->info.positioni));
+			fprintf(f, " ,");
+		}
+	}
+	pw_properties_serialize_dict(f, &data->capture_props->dict, 0);
+	fprintf(f, " }");
+	fclose(f);
+
+	data->mod = pw_context_load_module(module->impl->context,
+			"libpipewire-module-pipe-tunnel",
+			args, NULL);
 
-	n_params = 0;
-	paramsn_params++ = spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat,
-			&data->info);
+	free(args);
 
-	if ((res = pw_stream_connect(data->capture,
-			PW_DIRECTION_INPUT,
-			PW_ID_ANY,
-			PW_STREAM_FLAG_AUTOCONNECT |
-			PW_STREAM_FLAG_MAP_BUFFERS |
-			PW_STREAM_FLAG_RT_PROCESS,
-			params, n_params)) < 0)
-		return res;
+	if (data->mod == NULL)
+		return -errno;
 
+	pw_impl_module_add_listener(data->mod,
+			&data->mod_listener,
+			&module_events, data);
 	return 0;
 }
 
@@ -190,19 +119,13 @@
 {
 	struct module_pipesink_data *d = module->user_data;
 
-	pw_properties_free(d->capture_props);
-	if (d->capture != NULL)
-		pw_stream_destroy(d->capture);
-	if (d->core != NULL)
-		pw_core_disconnect(d->core);
-	if (d->filename) {
-		if (d->do_unlink_fifo)
-			unlink(d->filename);
-		free(d->filename);
+	if (d->mod) {
+		spa_hook_remove(&d->mod_listener);
+		pw_impl_module_destroy(d->mod);
+		d->mod = NULL;
 	}
-	if (d->fd >= 0)
-		close(d->fd);
-
+	pw_properties_free(d->capture_props);
+	free(d->filename);
 	return 0;
 }
 
@@ -211,6 +134,7 @@
 	{ PW_KEY_MODULE_DESCRIPTION, "Pipe sink" },
 	{ PW_KEY_MODULE_USAGE, "file=<name of the FIFO special file to use> "
 				"sink_name=<name for the sink> "
+				"sink_properties=<sink properties> "
 				"format=<sample format> "
 				"rate=<sample rate> "
 				"channels=<number of channels> "
@@ -218,126 +142,63 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_pipe_sink(struct impl *impl, const char *argument)
+static int module_pipe_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_pipesink_data *d;
-	struct pw_properties *props = NULL, *capture_props = NULL;
+	struct module_pipesink_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *capture_props = NULL;
 	struct spa_audio_info_raw info = { 0 };
-	struct stat st;
 	const char *str;
 	char *filename = NULL;
-	bool do_unlink_fifo;
 	int res = 0;
-	int fd = -1;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_pipe_sink_info));
 	capture_props = pw_properties_new(NULL, NULL);
-	if (!props || !capture_props) {
+	if (!capture_props) {
 		res = -EINVAL;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
 
+	info.format = SPA_AUDIO_FORMAT_S16;
 	if ((str = pw_properties_get(props, "format")) != NULL) {
 		info.format = format_paname2id(str, strlen(str));
 		pw_properties_set(props, "format", NULL);
 	}
-
 	if ((str = pw_properties_get(props, "sink_name")) != NULL) {
 		pw_properties_set(capture_props, PW_KEY_NODE_NAME, str);
 		pw_properties_set(props, "sink_name", NULL);
 	}
+	if ((str = pw_properties_get(props, "sink_properties")) != NULL)
+		module_args_add_props(capture_props, str);
 
 	if ((str = pw_properties_get(props, "file")) != NULL) {
 		filename = strdup(str);
 		pw_properties_set(props, "file", NULL);
-	} else {
-		filename = strdup(DEFAULT_FILE_NAME);
-	}
-
-	do_unlink_fifo = false;
-	if (mkfifo(filename, 0666) < 0) {
-		if (errno != EEXIST) {
-			res = -errno;
-			pw_log_error("mkfifo('%s'): %s", filename, spa_strerror(res));
-			goto out;
-		}
-	} else {
-		do_unlink_fifo = true;
-		/*
-		 * Our umask is 077, so the pipe won't be created with the
-		 * requested permissions. Let's fix the permissions with chmod().
-		 */
-		if (chmod(filename, 0666) < 0)
-			pw_log_warn("chmod('%s'): %s", filename, spa_strerror(-errno));
-	}
-
-	if ((fd = open(filename, O_RDWR | O_CLOEXEC | O_NONBLOCK, 0)) <= 0) {
-		res = -errno;
-		pw_log_error("open('%s'): %s", filename, spa_strerror(res));
-		goto out;
 	}
 
-	if (fstat(fd, &st) < 0) {
-		res = -errno;
-		pw_log_error("fstat('%s'): %s", filename, spa_strerror(res));
-		goto out;
-	}
-
-	if (!S_ISFIFO(st.st_mode)) {
-		pw_log_error("'%s' is not a FIFO.", filename);
-		goto out;
-	}
-
-	if (pw_properties_get(capture_props, PW_KEY_NODE_VIRTUAL) == NULL)
-		pw_properties_set(capture_props, PW_KEY_NODE_VIRTUAL, "true");
-	pw_properties_set(capture_props, PW_KEY_MEDIA_CLASS, "Audio/Sink");
-
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->capture_props = capture_props;
 	d->info = info;
-	d->fd = fd;
 	d->filename = filename;
-	d->do_unlink_fifo = do_unlink_fifo;
-
-	pw_log_info("Successfully loaded module-pipe-sink");
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(capture_props);
-	if (filename) {
-		if (do_unlink_fifo)
-			unlink(filename);
-		free(filename);
-	}
-	if (fd >= 0)
-		close(fd);
-	errno = -res;
-
-	return NULL;
+	free(filename);
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_pipe_sink) = {
 	.name = "module-pipe-sink",
-	.create = create_module_pipe_sink,
+	.prepare = module_pipe_sink_prepare,
 	.load = module_pipe_sink_load,
 	.unload = module_pipe_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_pipe_sink_info),
+	.data_size = sizeof(struct module_pipesink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-pipe-source.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-pipe-source.c Changed

@@ -40,171 +40,78 @@
 PW_LOG_TOPIC_STATIC(mod_topic, "mod." NAME);
 #define PW_LOG_TOPIC_DEFAULT mod_topic
 
-
-#define DEFAULT_FILE_NAME "/tmp/music.input"
-
 struct module_pipesrc_data {
 	struct module *module;
-	struct pw_core *core;
-
-	struct pw_stream *playback;
 
-	struct spa_hook core_listener;
-	struct spa_hook playback_listener;
+	struct spa_hook mod_listener;
+	struct pw_impl_module *mod;
 
 	struct pw_properties *playback_props;
-
 	struct spa_audio_info_raw info;
-
-	bool do_unlink;
 	char *filename;
-	int fd;
-
-	uint32_t stride;
-
-	uint32_t leftover_count;
-	uint8_t leftover; /* `stride` bytes for storing a partial sample */
 };
 
-static void playback_process(void *data)
-{
-	struct module_pipesrc_data *impl = data;
-	struct spa_chunk *chunk;
-	struct pw_buffer *buffer;
-	struct spa_data *d;
-	uint32_t left, leftover;
-	ssize_t bytes_read;
-
-	if ((buffer = pw_stream_dequeue_buffer(impl->playback)) == NULL) {
-		pw_log_warn("Out of playback buffers: %m");
-		return;
-	}
-
-	d = &buffer->buffer->datas0;
-	if (d->data == NULL)
-		return;
-
-	left = d->maxsize;
-	spa_assert(left >= impl->leftover_count);
-
-	chunk = d->chunk;
-
-	chunk->offset = 0;
-	chunk->stride = impl->stride;
-	chunk->size = impl->leftover_count;
-
-	memcpy(d->data, impl->leftover, impl->leftover_count);
-
-	left -= impl->leftover_count;
-
-	bytes_read = read(impl->fd, SPA_PTROFF(d->data, chunk->size, void), left);
-	if (bytes_read < 0) {
-		const bool important = !(errno == EINTR
-					 || errno == EAGAIN
-					 || errno == EWOULDBLOCK);
-
-		if (important)
-			pw_log_warn("failed to read from pipe (%s): %s",
-				    impl->filename, strerror(errno));
-	}
-	else {
-		chunk->size += bytes_read;
-	}
-
-	leftover = chunk->size % impl->stride;
-	chunk->size -= leftover;
-
-	memcpy(impl->leftover, SPA_PTROFF(d->data, chunk->size, void), leftover);
-	impl->leftover_count = leftover;
-
-	pw_stream_queue_buffer(impl->playback, buffer);
-}
-
-static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
+static void module_destroy(void *data)
 {
 	struct module_pipesrc_data *d = data;
-
-	pw_log_error("error id:%u seq:%d res:%d (%s): %s",
-			id, seq, res, spa_strerror(res), message);
-
-	if (id == PW_ID_CORE && res == -EPIPE)
-		module_schedule_unload(d->module);
+	spa_hook_remove(&d->mod_listener);
+	d->mod = NULL;
+	module_schedule_unload(d->module);
 }
 
-static const struct pw_core_events core_events = {
-	PW_VERSION_CORE_EVENTS,
-	.error = on_core_error,
-};
-
-static void on_stream_state_changed(void *data, enum pw_stream_state old,
-		enum pw_stream_state state, const char *error)
-{
-	struct module_pipesrc_data *d = data;
-
-	switch (state) {
-	case PW_STREAM_STATE_UNCONNECTED:
-		pw_log_info("stream disconnected, unloading");
-		module_schedule_unload(d->module);
-		break;
-	case PW_STREAM_STATE_ERROR:
-		pw_log_error("stream error: %s", error);
-		break;
-	default:
-		break;
-	}
-}
-
-static const struct pw_stream_events out_stream_events = {
-	PW_VERSION_STREAM_EVENTS,
-	.state_changed = on_stream_state_changed,
-	.process = playback_process
+static const struct pw_impl_module_events module_events = {
+	PW_VERSION_IMPL_MODULE_EVENTS,
+	.destroy = module_destroy
 };
 
 static int module_pipe_source_load(struct client *client, struct module *module)
 {
 	struct module_pipesrc_data *data = module->user_data;
-	int res;
-	uint32_t n_params;
-	const struct spa_pod *params1;
-	uint8_t buffer1024;
-	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
-
-	data->core = pw_context_connect(module->impl->context,
-			pw_properties_copy(client->props),
-			0);
-	if (data->core == NULL)
-		return -errno;
-
-	pw_core_add_listener(data->core,
-			&data->core_listener,
-			&core_events, data);
+	FILE *f;
+	char *args;
+	size_t size;
+	uint32_t i;
 
 	pw_properties_setf(data->playback_props, "pulse.module.id",
 			"%u", module->index);
 
-	data->playback = pw_stream_new(data->core,
-			"pipesource playback", data->playback_props);
-	data->playback_props = NULL;
-	if (data->playback == NULL)
+	if ((f = open_memstream(&args, &size)) == NULL)
 		return -errno;
 
-	pw_stream_add_listener(data->playback,
-			&data->playback_listener,
-			&out_stream_events, data);
+	fprintf(f, "{");
+	fprintf(f, " \"tunnel.mode\" = \"source\" ");
+	if (data->filename != NULL)
+		fprintf(f, " \"pipe.filename\": \"%s\"", data->filename);
+	if (data->info.format != 0)
+		fprintf(f, " \"audio.format\": \"%s\"", format_id2name(data->info.format));
+	if (data->info.rate != 0)
+		fprintf(f, " \"audio.rate\": %u,", data->info.rate);
+	if (data->info.channels != 0) {
+		fprintf(f, " \"audio.channels\": %u,", data->info.channels);
+		if (!(data->info.flags & SPA_AUDIO_FLAG_UNPOSITIONED)) {
+			fprintf(f, " \"audio.position\":  ");
+			for (i = 0; i < data->info.channels; i++)
+				fprintf(f, "%s\"%s\"", i == 0 ? "" : ",",
+					channel_id2name(data->info.positioni));
+			fprintf(f, " ,");
+		}
+	}
+	pw_properties_serialize_dict(f, &data->playback_props->dict, 0);
+	fprintf(f, " }");
+	fclose(f);
+
+	data->mod = pw_context_load_module(module->impl->context,
+			"libpipewire-module-pipe-tunnel",
+			args, NULL);
 
-	n_params = 0;
-	paramsn_params++ = spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat,
-			&data->info);
+	free(args);
 
-	if ((res = pw_stream_connect(data->playback,
-			PW_DIRECTION_OUTPUT,
-			PW_ID_ANY,
-			PW_STREAM_FLAG_AUTOCONNECT |
-			PW_STREAM_FLAG_MAP_BUFFERS |
-			PW_STREAM_FLAG_RT_PROCESS,
-			params, n_params)) < 0)
-		return res;
+	if (data->mod == NULL)
+		return -errno;
 
+	pw_impl_module_add_listener(data->mod,
+			&data->mod_listener,
+			&module_events, data);
 	return 0;
 }
 
@@ -212,17 +119,13 @@
 {
 	struct module_pipesrc_data *d = module->user_data;
 
+	if (d->mod) {
+		spa_hook_remove(&d->mod_listener);
+		pw_impl_module_destroy(d->mod);
+		d->mod = NULL;
+	}
 	pw_properties_free(d->playback_props);
-	if (d->playback != NULL)
-		pw_stream_destroy(d->playback);
-	if (d->core != NULL)
-		pw_core_disconnect(d->core);
-	if (d->do_unlink)
-		unlink(d->filename);
 	free(d->filename);
-	if (d->fd >= 0)
-		close(d->fd);
-
 	return 0;
 }
 
@@ -231,6 +134,7 @@
 	{ PW_KEY_MODULE_DESCRIPTION, "Pipe source" },
 	{ PW_KEY_MODULE_USAGE, "file=<name of the FIFO special file to use> "
 				"source_name=<name for the source> "
+				"source_properties=<source properties> "
 				"format=<sample format> "
 				"rate=<sample rate> "
 				"channels=<number of channels> "
@@ -238,164 +142,63 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_pipe_source(struct impl *impl, const char *argument)
+static int module_pipe_source_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_pipesrc_data *d;
-	struct pw_properties *props = NULL, *playback_props = NULL;
+	struct module_pipesrc_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *playback_props = NULL;
 	struct spa_audio_info_raw info = { 0 };
-	struct stat st;
 	const char *str;
-	bool do_unlink = false;
 	char *filename = NULL;
-	int stride, res = 0;
-	int fd = -1;
+	int res = 0;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_pipe_source_info));
 	playback_props = pw_properties_new(NULL, NULL);
-	if (!props || !playback_props) {
+	if (!playback_props) {
 		res = -errno;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
 
+	info.format = SPA_AUDIO_FORMAT_S16;
 	if ((str = pw_properties_get(props, "format")) != NULL) {
 		info.format = format_paname2id(str, strlen(str));
 		pw_properties_set(props, "format", NULL);
 	}
-
-	switch (info.format) {
-	case SPA_AUDIO_FORMAT_U8:
-		stride = info.channels;
-		break;
-	case SPA_AUDIO_FORMAT_S16_LE:
-	case SPA_AUDIO_FORMAT_S16_BE:
-	case SPA_AUDIO_FORMAT_S16P:
-		stride = 2 * info.channels;
-		break;
-	case SPA_AUDIO_FORMAT_S24_LE:
-	case SPA_AUDIO_FORMAT_S24_BE:
-	case SPA_AUDIO_FORMAT_S24P:
-		stride = 3 * info.channels;
-		break;
-	case SPA_AUDIO_FORMAT_F32_LE:
-	case SPA_AUDIO_FORMAT_F32_BE:
-	case SPA_AUDIO_FORMAT_F32P:
-	case SPA_AUDIO_FORMAT_S32_LE:
-	case SPA_AUDIO_FORMAT_S32_BE:
-	case SPA_AUDIO_FORMAT_S32P:
-	case SPA_AUDIO_FORMAT_S24_32_LE:
-	case SPA_AUDIO_FORMAT_S24_32_BE:
-	case SPA_AUDIO_FORMAT_S24_32P:
-		stride = 4 * info.channels;
-		break;
-	default:
-		pw_log_error("Invalid audio format");
-		res = -EINVAL;
-		goto out;
-	}
-
 	if ((str = pw_properties_get(props, "source_name")) != NULL) {
 		pw_properties_set(playback_props, PW_KEY_NODE_NAME, str);
 		pw_properties_set(props, "source_name", NULL);
 	}
+	if ((str = pw_properties_get(props, "source_properties")) != NULL)
+		module_args_add_props(playback_props, str);
 
 	if ((str = pw_properties_get(props, "file")) != NULL) {
 		filename = strdup(str);
 		pw_properties_set(props, "file", NULL);
-	} else {
-		filename = strdup(DEFAULT_FILE_NAME);
-	}
-
-	if (filename == NULL) {
-		res = -ENOMEM;
-		goto out;
-	}
-
-	if (mkfifo(filename, 0666) < 0) {
-		if (errno != EEXIST) {
-			res = -errno;
-			pw_log_error("mkfifo('%s'): %s", filename, spa_strerror(res));
-			goto out;
-		}
-
-		do_unlink = false;
-	} else {
-		/*
-		 * Our umask is 077, so the pipe won't be created with the
-		 * requested permissions. Let's fix the permissions with chmod().
-		 */
-		if (chmod(filename, 0666) < 0)
-			pw_log_warn("chmod('%s'): %s", filename, spa_strerror(-errno));
-
-		do_unlink = true;
 	}
 
-	if ((fd = open(filename, O_RDONLY | O_CLOEXEC | O_NONBLOCK, 0)) <= 0) {
-		res = -errno;
-        	pw_log_error("open('%s'): %s", filename, spa_strerror(res));
-		goto out;
-	}
-
-	if (fstat(fd, &st) < 0) {
-		res = -errno;
-		pw_log_error("fstat('%s'): %s", filename, spa_strerror(res));
-		goto out;
-	}
-
-	if (!S_ISFIFO(st.st_mode)) {
-		res = -EEXIST;
-		pw_log_error("'%s' is not a FIFO", filename);
-		goto out;
-	}
-
-	if (pw_properties_get(playback_props, PW_KEY_NODE_VIRTUAL) == NULL)
-		pw_properties_set(playback_props, PW_KEY_NODE_VIRTUAL, "true");
-	pw_properties_set(playback_props, PW_KEY_MEDIA_CLASS, "Audio/Source");
-
-	module = module_new(impl, sizeof(*d) + stride);
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->playback_props = playback_props;
 	d->info = info;
-	d->fd = fd;
 	d->filename = filename;
-	d->do_unlink = do_unlink;
-	d->stride = stride;
-
-	pw_log_info("Successfully loaded module-pipe-source");
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(playback_props);
-	if (do_unlink)
-		unlink(filename);
 	free(filename);
-	if (fd >= 0)
-		close(fd);
-	errno = -res;
-
-	return NULL;
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_pipe_source) = {
 	.name = "module-pipe-source",
-	.create = create_module_pipe_source,
+	.prepare = module_pipe_source_prepare,
 	.load = module_pipe_source_load,
 	.unload = module_pipe_source_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_pipe_source_info),
+	.data_size = sizeof(struct module_pipesrc_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-raop-discover.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-raop-discover.c Changed

@@ -92,44 +92,22 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_raop_discover(struct impl *impl, const char *argument)
+static int module_raop_discover_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_raop_discover_data *d;
-	struct pw_properties *props = NULL;
-	int res;
-
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_raop_discover_info));
-	if (props == NULL) {
-		res = -errno;
-		goto out;
-	}
-	if (argument != NULL)
-		module_args_add_props(props, argument);
+	struct module_raop_discover_data * const data = module->user_data;
+	data->module = module;
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
-	d->module = module;
-
-	return module;
-out:
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
+	return 0;
 }
 
 DEFINE_MODULE_INFO(module_raop_discover) = {
 	.name = "module-raop-discover",
 	.load_once = true,
-	.create = create_module_raop_discover,
+	.prepare = module_raop_discover_prepare,
 	.load = module_raop_discover_load,
 	.unload = module_raop_discover_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_raop_discover_info),
+	.data_size = sizeof(struct module_raop_discover_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-remap-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-remap-sink.c Changed

@@ -143,11 +143,11 @@
 	pw_properties_set(props, SPA_KEY_AUDIO_POSITION, s);
 }
 
-struct module *create_module_remap_sink(struct impl *impl, const char *argument)
+static int module_remap_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_remap_sink_data *d;
-	struct pw_properties *props = NULL, *playback_props = NULL, *capture_props = NULL;
+	struct module_remap_sink_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *playback_props = NULL, *capture_props = NULL;
 	const char *str, *master;
 	struct spa_audio_info_raw capture_info = { 0 };
 	struct spa_audio_info_raw playback_info = { 0 };
@@ -155,15 +155,12 @@
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_remap_sink_info));
 	capture_props = pw_properties_new(NULL, NULL);
 	playback_props = pw_properties_new(NULL, NULL);
-	if (!props || !capture_props || !playback_props) {
+	if (!capture_props || !playback_props) {
 		res = -EINVAL;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	master = pw_properties_get(props, "master");
 	if (pw_properties_get(props, "sink_name") == NULL) {
@@ -204,7 +201,7 @@
 		pw_properties_set(props, "master", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &capture_info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &capture_info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -235,30 +232,23 @@
 	if (pw_properties_get(playback_props, PW_KEY_NODE_PASSIVE) == NULL)
 		pw_properties_set(playback_props, PW_KEY_NODE_PASSIVE, "true");
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->capture_props = capture_props;
 	d->playback_props = playback_props;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(playback_props);
 	pw_properties_free(capture_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_remap_sink) = {
 	.name = "module-remap-sink",
-	.create = create_module_remap_sink,
+	.prepare = module_remap_sink_prepare,
 	.load = module_remap_sink_load,
 	.unload = module_remap_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_remap_sink_info),
+	.data_size = sizeof(struct module_remap_sink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-remap-source.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-remap-source.c Changed

@@ -143,11 +143,11 @@
 	pw_properties_set(props, SPA_KEY_AUDIO_POSITION, s);
 }
 
-struct module *create_module_remap_source(struct impl *impl, const char *argument)
+static int module_remap_source_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_remap_source_data *d;
-	struct pw_properties *props = NULL, *playback_props = NULL, *capture_props = NULL;
+	struct module_remap_source_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *playback_props = NULL, *capture_props = NULL;
 	const char *str, *master;
 	struct spa_audio_info_raw capture_info = { 0 };
 	struct spa_audio_info_raw playback_info = { 0 };
@@ -155,15 +155,12 @@
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_remap_source_info));
 	capture_props = pw_properties_new(NULL, NULL);
 	playback_props = pw_properties_new(NULL, NULL);
-	if (!props || !capture_props || !playback_props) {
+	if (!capture_props || !playback_props) {
 		res = -EINVAL;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	master = pw_properties_get(props, "master");
 	if (pw_properties_get(props, "source_name") == NULL) {
@@ -204,7 +201,7 @@
 		pw_properties_set(props, "master", NULL);
 	}
 
-	if (module_args_to_audioinfo(impl, props, &playback_info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &playback_info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -235,30 +232,23 @@
 	if (pw_properties_get(capture_props, PW_KEY_NODE_PASSIVE) == NULL)
 		pw_properties_set(capture_props, PW_KEY_NODE_PASSIVE, "true");
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->capture_props = capture_props;
 	d->playback_props = playback_props;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(playback_props);
 	pw_properties_free(capture_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_remap_source) = {
 	.name = "module-remap-source",
-	.create = create_module_remap_source,
+	.prepare = module_remap_source_prepare,
 	.load = module_remap_source_load,
 	.unload = module_remap_source_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_remap_source_info),
+	.data_size = sizeof(struct module_remap_source_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-roc-sink-input.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-roc-sink-input.c Changed

@@ -124,27 +124,23 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_roc_sink_input(struct impl *impl, const char *argument)
+static int module_roc_sink_input_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_roc_sink_input_data *d;
-	struct pw_properties *props = NULL, *source_props = NULL, *roc_props = NULL;
+	struct module_roc_sink_input_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *source_props = NULL, *roc_props = NULL;
 	const char *str;
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_roc_sink_input_info));
 	source_props = pw_properties_new(NULL, NULL);
 	roc_props = pw_properties_new(NULL, NULL);
-	if (!props || !source_props || !roc_props) {
+	if (!source_props || !roc_props) {
 		res = -errno;
 		goto out;
 	}
 
-	if (argument != NULL)
-		module_args_add_props(props, argument);
-
 	if ((str = pw_properties_get(props, "sink")) != NULL) {
 		pw_properties_set(source_props, PW_KEY_TARGET_OBJECT, str);
 		pw_properties_set(props, "sink", NULL);
@@ -184,30 +180,23 @@
 		pw_properties_set(props, "fec_code", NULL);
 	}
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->source_props = source_props;
 	d->roc_props = roc_props;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(source_props);
 	pw_properties_free(roc_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_roc_sink_input) = {
 	.name = "module-roc-sink-input",
-	.create = create_module_roc_sink_input,
+	.prepare = module_roc_sink_input_prepare,
 	.load = module_roc_sink_input_load,
 	.unload = module_roc_sink_input_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_roc_sink_input_info),
+	.data_size = sizeof(struct module_roc_sink_input_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-roc-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-roc-sink.c Changed

@@ -123,25 +123,22 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_roc_sink(struct impl *impl, const char *argument)
+static int module_roc_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_roc_sink_data *d;
-	struct pw_properties *props = NULL, *sink_props = NULL, *roc_props = NULL;
+	struct module_roc_sink_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *sink_props = NULL, *roc_props = NULL;
 	const char *str;
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_roc_sink_info));
 	sink_props = pw_properties_new(NULL, NULL);
 	roc_props = pw_properties_new(NULL, NULL);
-	if (!props || !sink_props || !roc_props) {
+	if (!sink_props || !roc_props) {
 		res = -errno;
 		goto out;
 	}
-	if (argument != NULL)
-		module_args_add_props(props, argument);
 
 	if ((str = pw_properties_get(props, "sink_name")) != NULL) {
 		pw_properties_set(sink_props, PW_KEY_NODE_NAME, str);
@@ -185,30 +182,23 @@
 		pw_properties_set(props, "fec_code", NULL);
 	}
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->sink_props = sink_props;
 	d->roc_props = roc_props;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(sink_props);
 	pw_properties_free(roc_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_roc_sink) = {
 	.name = "module-roc-sink",
-	.create = create_module_roc_sink,
+	.prepare = module_roc_sink_prepare,
 	.load = module_roc_sink_load,
 	.unload = module_roc_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_roc_sink_info),
+	.data_size = sizeof(struct module_roc_sink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-roc-source.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-roc-source.c Changed

@@ -124,27 +124,23 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_roc_source(struct impl *impl, const char *argument)
+static int module_roc_source_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_roc_source_data *d;
-	struct pw_properties *props = NULL, *source_props = NULL, *roc_props = NULL;
+	struct module_roc_source_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *source_props = NULL, *roc_props = NULL;
 	const char *str;
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_roc_source_info));
 	source_props = pw_properties_new(NULL, NULL);
 	roc_props = pw_properties_new(NULL, NULL);
-	if (!props || !source_props || !roc_props) {
+	if (!source_props || !roc_props) {
 		res = -errno;
 		goto out;
 	}
 
-	if (argument != NULL)
-		module_args_add_props(props, argument);
-
 	if ((str = pw_properties_get(props, "source_name")) != NULL) {
 		pw_properties_set(source_props, PW_KEY_NODE_NAME, str);
 		pw_properties_set(props, "source_name", NULL);
@@ -189,30 +185,23 @@
 		pw_properties_set(props, "fec_code", NULL);
 	}
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->source_props = source_props;
 	d->roc_props = roc_props;
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(source_props);
 	pw_properties_free(roc_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_roc_source) = {
 	.name = "module-roc-source",
-	.create = create_module_roc_source,
+	.prepare = module_roc_source_prepare,
 	.load = module_roc_source_load,
 	.unload = module_roc_source_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_roc_source_info),
+	.data_size = sizeof(struct module_roc_source_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-simple-protocol-tcp.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-simple-protocol-tcp.c Changed

@@ -130,25 +130,17 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_simple_protocol_tcp(struct impl *impl, const char *argument)
+static int module_simple_protocol_tcp_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_simple_protocol_tcp_data *d;
-	struct pw_properties *props = NULL, *module_props = NULL;
+	struct module_simple_protocol_tcp_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *module_props = NULL;
 	const char *str, *port, *listen;
 	struct spa_audio_info_raw info = { 0 };
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_simple_protocol_tcp_info));
-	if (props == NULL) {
-		res = -errno;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
-
 	module_props = pw_properties_new(NULL, NULL);
 	if (module_props == NULL) {
 		res = -errno;
@@ -160,7 +152,7 @@
 				format_id2name(format_paname2id(str, strlen(str))));
 		pw_properties_set(props, "format", NULL);
 	}
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -197,29 +189,22 @@
 	pw_properties_setf(module_props, "server.address", " \"tcp:%s%s%s\" ",
 			listen ? listen : "", listen ? ":" : "", port);
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->module_props = module_props;
 	d->info = info;
 
-	return module;
+	return 0;
 out:
 	pw_properties_free(module_props);
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_simple_protocol_tcp) = {
 	.name = "module-simple-protocol-tcp",
-	.create = create_module_simple_protocol_tcp,
+	.prepare = module_simple_protocol_tcp_prepare,
 	.load = module_simple_protocol_tcp_load,
 	.unload = module_simple_protocol_tcp_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_simple_protocol_tcp_info),
+	.data_size = sizeof(struct module_simple_protocol_tcp_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-switch-on-connect.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-switch-on-connect.c Changed

@@ -52,7 +52,7 @@
 	struct spa_hook manager_listener;
 	struct pw_manager_object *metadata_default;
 
-	regex_t *blocklist;
+	regex_t blocklist;
 
 	int sync_seq;
 
@@ -122,7 +122,7 @@
 		return;
 	}
 
-	if (d->blocklist && regexec(d->blocklist, name, 0, NULL, 0) == 0) {
+	if (regexec(&d->blocklist, name, 0, NULL, 0) == 0) {
 		pw_log_debug("not switching to blocklisted device");
 		return;
 	}
@@ -224,11 +224,7 @@
 		d->core = NULL;
 	}
 
-	if (d->blocklist) {
-		regfree(d->blocklist);
-		free(d->blocklist);
-		d->blocklist = NULL;
-	}
+	regfree(&d->blocklist);
 
 	return 0;
 }
@@ -245,26 +241,15 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_switch_on_connect(struct impl *impl, const char *argument)
+static int module_switch_on_connect_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_switch_on_connect_data *d;
-	struct pw_properties *props = NULL;
-	regex_t *blocklist = NULL;
+	struct module_switch_on_connect_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
 	bool only_from_unavailable = false, ignore_virtual = true;
 	const char *str;
-	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_switch_on_connect_info));
-	if (!props) {
-		res = -EINVAL;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
-
 	if ((str = pw_properties_get(props, "only_from_unavailable")) != NULL) {
 		only_from_unavailable = module_args_parse_bool(str);
 		pw_properties_set(props, "only_from_unavailable", NULL);
@@ -275,33 +260,15 @@
 		pw_properties_set(props, "ignore_virtual", NULL);
 	}
 
-	if ((blocklist = malloc(sizeof(regex_t))) == NULL) {
-		res = -ENOMEM;
-		goto out;
-	}
-
 	if ((str = pw_properties_get(props, "blocklist")) == NULL)
 		str = DEFAULT_BLOCKLIST;
 
-	if ((res = regcomp(blocklist, str, REG_NOSUB | REG_EXTENDED)) != 0) {
-		free(blocklist);
-		blocklist = NULL;
-		res = -EINVAL;
-		goto out;
-	}
+	if (regcomp(&d->blocklist, str, REG_NOSUB | REG_EXTENDED) != 0)
+		return -EINVAL;
 
 	pw_properties_set(props, "blocklist", NULL);
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
-	d->blocklist = blocklist;
 	d->ignore_virtual = ignore_virtual;
 	d->only_from_unavailable = only_from_unavailable;
 
@@ -310,23 +277,15 @@
 		pw_log_warn("only_from_unavailable is not implemented");
 	}
 
-	return module;
-
-out:
-	pw_properties_free(props);
-	if (blocklist) {
-		regfree(blocklist);
-		free(blocklist);
-	}
-	errno = -res;
-
-	return NULL;
+	return 0;
 }
 
 DEFINE_MODULE_INFO(module_switch_on_connect) = {
 	.name = "module-switch-on-connect",
 	.load_once = true,
-	.create = create_module_switch_on_connect,
+	.prepare = module_switch_on_connect_prepare,
 	.load = module_switch_on_connect_load,
 	.unload = module_switch_on_connect_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_switch_on_connect_info),
+	.data_size = sizeof(struct module_switch_on_connect_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-tunnel-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-tunnel-sink.c Changed

@@ -81,7 +81,7 @@
 	fprintf(f, "{");
 	pw_properties_serialize_dict(f, &module->props->dict, 0);
 	fprintf(f, " pulse.server.address = \"%s\" ", server);
-	fprintf(f, " tunnel.mode = playback ");
+	fprintf(f, " tunnel.mode = sink ");
 	if (data->latency_msec > 0)
 		fprintf(f, " pulse.latency = %u ", data->latency_msec);
 	fprintf(f, " stream.props = {");
@@ -149,25 +149,22 @@
 	pw_properties_set(props, SPA_KEY_AUDIO_POSITION, s);
 }
 
-struct module *create_module_tunnel_sink(struct impl *impl, const char *argument)
+static int module_tunnel_sink_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_tunnel_sink_data *d;
-	struct pw_properties *props = NULL, *stream_props = NULL;
+	struct module_tunnel_sink_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *stream_props = NULL;
 	const char *str, *server, *remote_sink_name;
 	struct spa_audio_info_raw info = { 0 };
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_tunnel_sink_info));
 	stream_props = pw_properties_new(NULL, NULL);
-	if (props == NULL || stream_props == NULL) {
+	if (stream_props == NULL) {
 		res = -ENOMEM;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	remote_sink_name = pw_properties_get(props, "sink");
 	if (remote_sink_name)
@@ -196,7 +193,7 @@
 		module_args_add_props(stream_props, str);
 		pw_properties_set(props, "sink_properties", NULL);
 	}
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
@@ -212,30 +209,23 @@
 		pw_properties_set(stream_props, PW_KEY_AUDIO_FORMAT, format_id2name(id));
 	}
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->stream_props = stream_props;
 
 	pw_properties_fetch_uint32(props, "latency_msec", &d->latency_msec);
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(stream_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_tunnel_sink) = {
 	.name = "module-tunnel-sink",
-	.create = create_module_tunnel_sink,
+	.prepare = module_tunnel_sink_prepare,
 	.load = module_tunnel_sink_load,
 	.unload = module_tunnel_sink_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_tunnel_sink_info),
+	.data_size = sizeof(struct module_tunnel_sink_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-tunnel-source.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-tunnel-source.c Changed

@@ -81,7 +81,7 @@
 	fprintf(f, "{");
 	pw_properties_serialize_dict(f, &module->props->dict, 0);
 	fprintf(f, " pulse.server.address = \"%s\" ", server);
-	fprintf(f, " tunnel.mode = capture ");
+	fprintf(f, " tunnel.mode = source ");
 	if (data->latency_msec > 0)
 		fprintf(f, " pulse.latency = %u ", data->latency_msec);
 	fprintf(f, " stream.props = {");
@@ -149,25 +149,22 @@
 	pw_properties_set(props, SPA_KEY_AUDIO_POSITION, s);
 }
 
-struct module *create_module_tunnel_source(struct impl *impl, const char *argument)
+static int module_tunnel_source_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_tunnel_source_data *d;
-	struct pw_properties *props = NULL, *stream_props = NULL;
+	struct module_tunnel_source_data * const d = module->user_data;
+	struct pw_properties * const props = module->props;
+	struct pw_properties *stream_props = NULL;
 	const char *str, *server, *remote_source_name;
 	struct spa_audio_info_raw info = { 0 };
 	int res;
 
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_tunnel_source_info));
 	stream_props = pw_properties_new(NULL, NULL);
-	if (props == NULL || stream_props == NULL) {
+	if (stream_props == NULL) {
 		res = -ENOMEM;
 		goto out;
 	}
-	if (argument)
-		module_args_add_props(props, argument);
 
 	remote_source_name = pw_properties_get(props, "source");
 	if (remote_source_name)
@@ -195,37 +192,30 @@
 		module_args_add_props(stream_props, str);
 		pw_properties_set(props, "source_properties", NULL);
 	}
-	if (module_args_to_audioinfo(impl, props, &info) < 0) {
+	if (module_args_to_audioinfo(module->impl, props, &info) < 0) {
 		res = -EINVAL;
 		goto out;
 	}
 
 	audio_info_to_props(&info, stream_props);
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
 	d->module = module;
 	d->stream_props = stream_props;
 
 	pw_properties_fetch_uint32(props, "latency_msec", &d->latency_msec);
 
-	return module;
+	return 0;
 out:
-	pw_properties_free(props);
 	pw_properties_free(stream_props);
-	errno = -res;
-	return NULL;
+
+	return res;
 }
 
 DEFINE_MODULE_INFO(module_tunnel_source) = {
 	.name = "module-tunnel-source",
-	.create = create_module_tunnel_source,
+	.prepare = module_tunnel_source_prepare,
 	.load = module_tunnel_source_load,
 	.unload = module_tunnel_source_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_tunnel_source_info),
+	.data_size = sizeof(struct module_tunnel_source_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-x11-bell.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-x11-bell.c Changed

@@ -100,6 +100,16 @@
 	return 0;
 }
 
+static int module_x11_bell_prepare(struct module * const module)
+{
+	PW_LOG_TOPIC_INIT(mod_topic);
+
+	struct module_x11_bell_data * const data = module->user_data;
+	data->module = module;
+
+	return 0;
+}
+
 static const struct spa_dict_item module_x11_bell_info = {
 	{ PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
 	{ PW_KEY_MODULE_DESCRIPTION, "X11 bell interceptor" },
@@ -110,39 +120,11 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_x11_bell(struct impl *impl, const char *argument)
-{
-	struct module *module;
-	struct pw_properties *props = NULL;
-	int res;
-
-	PW_LOG_TOPIC_INIT(mod_topic);
-
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_x11_bell_info));
-	if (props == NULL) {
-		res = -EINVAL;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
-
-	module = module_new(impl, sizeof(struct module_x11_bell_data));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-	module->props = props;
-
-	return module;
-out:
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
-}
-
 DEFINE_MODULE_INFO(module_x11_bell) = {
 	.name = "module-x11-bell",
-	.create = create_module_x11_bell,
+	.prepare = module_x11_bell_prepare,
 	.load = module_x11_bell_load,
 	.unload = module_x11_bell_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_x11_bell_info),
+	.data_size = sizeof(struct module_x11_bell_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-zeroconf-discover.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-zeroconf-discover.c Changed

@@ -92,44 +92,22 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_zeroconf_discover(struct impl *impl, const char *argument)
+static int module_zeroconf_discover_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_zeroconf_discover_data *d;
-	struct pw_properties *props = NULL;
-	int res;
-
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_zeroconf_discover_info));
-	if (props == NULL) {
-		res = -errno;
-		goto out;
-	}
-	if (argument != NULL)
-		module_args_add_props(props, argument);
+	struct module_zeroconf_discover_data * const data = module->user_data;
+	data->module = module;
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
-	d->module = module;
-
-	return module;
-out:
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
+	return 0;
 }
 
 DEFINE_MODULE_INFO(module_zeroconf_discover) = {
 	.name = "module-zeroconf-discover",
 	.load_once = true,
-	.create = create_module_zeroconf_discover,
+	.prepare = module_zeroconf_discover_prepare,
 	.load = module_zeroconf_discover_load,
 	.unload = module_zeroconf_discover_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_zeroconf_discover_info),
+	.data_size = sizeof(struct module_zeroconf_discover_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/modules/module-zeroconf-publish.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/modules/module-zeroconf-publish.c Changed

@@ -545,10 +545,20 @@
 static void manager_added(void *d, struct pw_manager_object *o)
 {
 	struct service *s;
+	struct pw_node_info *info;
+	const char *str;
 
 	if (!pw_manager_object_is_sink(o) && !pw_manager_object_is_source(o))
 		return;
 
+	info = o->info;
+	if (info == NULL || info->props == NULL)
+		return;
+
+	if ((str = spa_dict_lookup(info->props, PW_KEY_NODE_NETWORK)) != NULL &&
+	    spa_atob(str))
+		return;
+
 	s = create_service(d, o);
 	if (s == NULL)
 		return;
@@ -637,46 +647,24 @@
 	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
-struct module *create_module_zeroconf_publish(struct impl *impl, const char *argument)
+static int module_zeroconf_publish_prepare(struct module * const module)
 {
-	struct module *module;
-	struct module_zeroconf_publish_data *d;
-	struct pw_properties *props = NULL;
-	int res;
-
 	PW_LOG_TOPIC_INIT(mod_topic);
 
-	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(module_zeroconf_publish_info));
-	if (!props) {
-		res = -errno;
-		goto out;
-	}
-	if (argument)
-		module_args_add_props(props, argument);
+	struct module_zeroconf_publish_data * const data = module->user_data;
+	data->module = module;
+	data->port = pw_properties_get_uint32(module->props, "port", PW_PROTOCOL_PULSE_DEFAULT_PORT);
+	spa_list_init(&data->pending);
+	spa_list_init(&data->published);
 
-	module = module_new(impl, sizeof(*d));
-	if (module == NULL) {
-		res = -errno;
-		goto out;
-	}
-
-	module->props = props;
-	d = module->user_data;
-	d->module = module;
-	d->port = pw_properties_get_uint32(props, "port", PW_PROTOCOL_PULSE_DEFAULT_PORT);
-	spa_list_init(&d->pending);
-	spa_list_init(&d->published);
-
-	return module;
-out:
-	pw_properties_free(props);
-	errno = -res;
-	return NULL;
+	return 0;
 }
 
 DEFINE_MODULE_INFO(module_zeroconf_publish) = {
 	.name = "module-zeroconf-publish",
-	.create = create_module_zeroconf_publish,
+	.prepare = module_zeroconf_publish_prepare,
 	.load = module_zeroconf_publish_load,
 	.unload = module_zeroconf_publish_unload,
+	.properties = &SPA_DICT_INIT_ARRAY(module_zeroconf_publish_info),
+	.data_size = sizeof(struct module_zeroconf_publish_data),
 };

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/pulse-server.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/pulse-server.c Changed

@@ -87,12 +87,22 @@
 #define DEFAULT_POSITION	" FL FR "
 
 #define MAX_FORMATS	32
+/* The max amount of data we send in one block when capturing. In PulseAudio this
+ * size is derived from the mempool PA_MEMPOOL_SLOT_SIZE */
+#define MAX_FRAGSIZE	(64*1024)
+
+#define TEMPORARY_MOVE_TIMEOUT	(SPA_NSEC_PER_SEC)
 
 bool debug_messages = false;
 
 struct latency_offset_data {
 	int64_t prev_latency_offset;
-	unsigned int initialized:1;
+	uint8_t initialized:1;
+};
+
+struct temporary_move_data {
+	uint32_t peer_index;
+	uint8_t used:1;
 };
 
 static struct sample *find_sample(struct impl *impl, uint32_t index, const char *name)
@@ -256,6 +266,75 @@
 	return 0;
 }
 
+static uint32_t get_temporary_move_target(struct client *client, struct pw_manager_object *o)
+{
+	struct temporary_move_data *d;
+
+	d = pw_manager_object_get_data(o, "temporary_move_data");
+	if (d == NULL || d->peer_index == SPA_ID_INVALID)
+		return SPA_ID_INVALID;
+
+	pw_log_debug("%s using temporary move target for index:%d -> index:%d",
+			client->name, o->index, d->peer_index);
+	d->used = true;
+	return d->peer_index;
+}
+
+static void set_temporary_move_target(struct client *client, struct pw_manager_object *o, uint32_t index)
+{
+	struct temporary_move_data *d;
+
+	if (!pw_manager_object_is_sink_input(o) && !pw_manager_object_is_source_output(o))
+		return;
+
+	if (index == SPA_ID_INVALID) {
+		d = pw_manager_object_get_data(o, "temporary_move_data");
+		if (d == NULL)
+			return;
+		if (d->peer_index != SPA_ID_INVALID)
+			pw_log_debug("cleared temporary move target for index:%d", o->index);
+		d->peer_index = SPA_ID_INVALID;
+		d->used = false;
+		return;
+	}
+
+	d = pw_manager_object_add_temporary_data(o, "temporary_move_data",
+			sizeof(struct temporary_move_data),
+			TEMPORARY_MOVE_TIMEOUT);
+	if (d == NULL)
+		return;
+
+	pw_log_debug("%s set temporary move target for index:%d to index:%d",
+			client->name, o->index, index);
+	d->peer_index = index;
+	d->used = false;
+}
+
+static void temporary_move_target_timeout(struct client *client, struct pw_manager_object *o)
+{
+	struct temporary_move_data *d = pw_manager_object_get_data(o, "temporary_move_data");
+	struct pw_manager_object *peer;
+
+	/*
+	 * Send change event if the temporary data was used, and the peer
+	 * is not what we claimed.
+	 */
+
+	if (d == NULL || d->peer_index == SPA_ID_INVALID || !d->used)
+		goto done;
+
+	peer = find_linked(client->manager, o->id, pw_manager_object_is_sink_input(o) ?
+			PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT);
+	if (peer == NULL || peer->index != d->peer_index) {
+		pw_log_debug("%s temporary move timeout for index:%d, send change event",
+				client->name, o->index);
+		send_object_event(client, o, SUBSCRIPTION_EVENT_CHANGE);
+	}
+
+done:
+	set_temporary_move_target(client, o, SPA_ID_INVALID);
+}
+
 static struct pw_manager_object *find_device(struct client *client,
 		uint32_t index, const char *name, bool sink, bool *is_monitor);
 
@@ -371,7 +450,11 @@
 	uint32_t frame_size, max_prebuf, minreq, latency, max_latency;
 	struct defs *defs = &s->impl->defs;
 
-	frame_size = s->frame_size;
+	if ((frame_size = s->frame_size) == 0)
+		frame_size = sample_spec_frame_size(&s->ss);
+	if (frame_size == 0)
+		frame_size = 4;
+
 	minreq = frac_to_bytes_round_up(s->min_req, &s->ss);
 	max_latency = defs->quantum_limit * frame_size;
 
@@ -503,6 +586,7 @@
 
 	missing = stream_pop_missing(stream);
 	stream->index = id_to_index(manager, stream->id);
+	stream->lat_usec = lat_usec;
 
 	pw_log_info("%s reply CREATE_PLAYBACK_STREAM tag:%u index:%u missing:%u lat:%"PRIu64,
 			client->name, stream->create_tag, stream->index, missing, lat_usec);
@@ -562,7 +646,10 @@
 {
 	uint32_t frame_size, minfrag, latency;
 
-	frame_size = s->frame_size;
+	if ((frame_size = s->frame_size) == 0)
+		frame_size = sample_spec_frame_size(&s->ss);
+	if (frame_size == 0)
+		frame_size = 4;
 
 	if (attr->maxlength == (uint32_t) -1 || attr->maxlength > MAXLENGTH)
 		attr->maxlength = MAXLENGTH;
@@ -646,6 +733,7 @@
 	lat_usec = set_record_buffer_attr(stream, &stream->attr);
 
 	stream->index = id_to_index(manager, stream->id);
+	stream->lat_usec = lat_usec;
 
 	pw_log_info("%s reply CREATE_RECORD_STREAM tag:%u index:%u latency:%"PRIu64,
 			client->name, stream->create_tag, stream->index, lat_usec);
@@ -710,6 +798,7 @@
 
 static int reply_create_stream(struct stream *stream, struct pw_manager_object *peer)
 {
+	stream->peer_index = peer->index;
 	return stream->direction == PW_DIRECTION_OUTPUT ?
 			reply_create_playback_stream(stream, peer) :
 			reply_create_record_stream(stream, peer);
@@ -740,17 +829,36 @@
 	}
 
 	if (spa_streq(o->type, PW_TYPE_INTERFACE_Link)) {
-		struct stream *s;
+		struct stream *s, *t;
 		struct pw_manager_object *peer = NULL;
-		spa_list_for_each(s, &client->pending_streams, link) {
-			peer = find_linked(manager, s->id, s->direction);
-			if (peer)
-				break;
-		}
-		if (peer) {
-			reply_create_stream(s, peer);
-			spa_list_remove(&s->link);
-			s->pending = false;
+		union pw_map_item *item;
+		pw_array_for_each(item, &client->streams.items) {
+			struct stream *s = item->data;
+			const char *peer_name;
+
+			if (pw_map_item_is_free(item) || s->pending)
+				continue;
+			if (s->peer_index == SPA_ID_INVALID)
+				continue;
+
+			peer = find_peer_for_link(manager, o, s->id, s->direction);
+			if (peer == NULL || peer->props == NULL ||
+			    peer->index == s->peer_index)
+				continue;
+
+			s->peer_index = peer->index;
+
+			peer_name = pw_properties_get(peer->props, PW_KEY_NODE_NAME);
+			if (peer_name != NULL)
+				stream_send_moved(s, peer->index, peer_name);
+		}
+		spa_list_for_each_safe(s, t, &client->pending_streams, link) {
+			peer = find_peer_for_link(manager, o, s->id, s->direction);
+			if (peer) {
+				reply_create_stream(s, peer);
+				spa_list_remove(&s->link);
+				s->pending = false;
+			}
 		}
 	}
 
@@ -766,6 +874,8 @@
 
 	send_object_event(client, o, SUBSCRIPTION_EVENT_CHANGE);
 
+	set_temporary_move_target(client, o, SPA_ID_INVALID);
+
 	send_latency_offset_subscribe_event(client, o);
 	send_default_change_subscribe_event(client, pw_manager_object_is_sink(o), pw_manager_object_is_source_or_monitor(o));
 }
@@ -786,6 +896,14 @@
 	}
 }
 
+static void manager_object_data_timeout(void *data, struct pw_manager_object *o, const char *key)
+{
+	struct client *client = data;
+
+	if (spa_streq(key, "temporary_move_data"))
+		temporary_move_target_timeout(client, o);
+}
+
 static int json_object_find(const char *obj, const char *key, char *value, size_t len)
 {
 	struct spa_json it2;
@@ -880,7 +998,8 @@
 	.updated = manager_updated,
 	.removed = manager_removed,
 	.metadata = manager_metadata,
-	.disconnect = manager_disconnect
+	.disconnect = manager_disconnect,
+	.object_data_timeout = manager_object_data_timeout,
 };
 
 static int do_set_client_name(struct client *client, uint32_t command, uint32_t tag, struct message *m)
@@ -1190,7 +1309,7 @@
 			pw_log_warn("%p: %s underrun read:%u avail:%d",
 					stream, client->name, index, avail);
 		} else {
-			if (avail > (int32_t)stream->attr.maxlength) {
+			if ((uint32_t)avail > stream->attr.maxlength) {
 				uint32_t skip = avail - stream->attr.fragsize;
 				/* overrun, catch up to latest fragment and send it */
 				pw_log_warn("%p: %s overrun recover read:%u avail:%d max:%u skip:%u",
@@ -1200,10 +1319,9 @@
 				avail = stream->attr.fragsize;
 			}
 
-			while (avail > 0) {
-				towrite = avail;
-				if (towrite > stream->attr.fragsize)
-					towrite = stream->attr.fragsize;
+			while ((uint32_t)avail >= stream->attr.fragsize) {
+				towrite = SPA_MIN(avail, MAX_FRAGSIZE);
+				towrite = SPA_ROUND_DOWN(towrite, stream->frame_size);
 
 				msg = message_alloc(impl, stream->channel, towrite);
 				if (msg == NULL)
@@ -1235,7 +1353,8 @@
 	void *p;
 	struct pw_buffer *buffer;
 	struct spa_buffer *buf;
-	uint32_t size, minreq = 0, index;
+	struct spa_data *d;
+	uint32_t offs, size, minreq = 0, index;
 	struct process_data pd;
 	bool do_flush = false;
 
@@ -1248,7 +1367,8 @@
 		return;
 
 	buf = buffer->buffer;
-	if ((p = buf->datas0.data) == NULL)
+	d = &buf->datas0;
+	if ((p = d->data) == NULL)
 		return;
 
 	spa_zero(pd);
@@ -1265,7 +1385,7 @@
 
 		if (avail < (int32_t)minreq || stream->corked) {
 			/* underrun, produce a silence buffer */
-			size = SPA_MIN(buf->datas0.maxsize, minreq);
+			size = SPA_MIN(d->maxsize, minreq);
 			memset(p, 0, size);
 
 			if (stream->draining && !stream->corked) {
@@ -1281,10 +1401,10 @@
 						stream->buffer, MAXLENGTH,
 						index % MAXLENGTH,
 						p, avail);
+					index += avail;
 				}
 				pd.playing_for = size;
 				pd.read_inc = size;
-				index += size;
 				spa_ringbuffer_read_update(&stream->ring, index);
 			}
 			pw_log_debug("%p: %s underrun read:%u avail:%d max:%u",
@@ -1301,7 +1421,7 @@
 				pd.read_inc = skip;
 				avail = stream->attr.maxlength;
 			}
-			size = SPA_MIN(buf->datas0.maxsize, (uint32_t)avail);
+			size = SPA_MIN(d->maxsize, (uint32_t)avail);
 			size = SPA_MIN(size, minreq);
 
 			spa_ringbuffer_read_data(&stream->ring,
@@ -1316,13 +1436,16 @@
 			pd.playing_for = size;
 			pd.underrun = false;
 		}
-		buf->datas0.chunk->offset = 0;
-		buf->datas0.chunk->stride = stream->frame_size;
-		buf->datas0.chunk->size = size;
+		d->chunk->offset = 0;
+		d->chunk->stride = stream->frame_size;
+		d->chunk->size = size;
 		buffer->size = size / stream->frame_size;
 	} else  {
 		int32_t filled = spa_ringbuffer_get_write_index(&stream->ring, &index);
-		size = buf->datas0.chunk->size;
+
+		offs = SPA_MIN(d->chunk->offset, d->maxsize);
+		size = SPA_MIN(d->chunk->size, d->maxsize - offs);
+
 		if (filled < 0) {
 			/* underrun, can't really happen because we never read more
 			 * than what's available on the other side  */
@@ -1340,7 +1463,7 @@
 		spa_ringbuffer_write_data(&stream->ring,
 				stream->buffer, MAXLENGTH,
 				index % MAXLENGTH,
-				SPA_PTROFF(p, buf->datas0.chunk->offset, void),
+				SPA_PTROFF(p, offs, void),
 				SPA_MIN(size, MAXLENGTH));
 
 		index += size;
@@ -1593,8 +1716,11 @@
 	stream->is_underrun = true;
 	stream->underrun_for = -1;
 
-	if (rate != 0)
+	if (rate != 0) {
 		pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", rate);
+		pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%u",
+				fix_playback_buffer_attr(stream, &attr), rate);
+	}
 	if (no_remix)
 		pw_properties_set(props, PW_KEY_STREAM_DONT_REMIX, "true");
 	flags = 0;
@@ -1851,8 +1977,11 @@
 	if (client->quirks & QUIRK_REMOVE_CAPTURE_DONT_MOVE)
 		no_move = false;
 
-	if (rate != 0)
+	if (rate != 0) {
 		pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", rate);
+		pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%u",
+				fix_record_buffer_attr(stream, &attr), rate);
+	}
 	if (peak_detect)
 		pw_properties_set(props, PW_KEY_STREAM_MONITOR, "true");
 	if (no_remix)
@@ -3362,7 +3491,7 @@
 	}
 	if (client->version >= 15) {
 		message_put(m,
-			TAG_PROPLIST, module->props,
+			TAG_PROPLIST, module->info->properties,
 			TAG_INVALID);
 	}
 	return 0;
@@ -3927,7 +4056,6 @@
 	struct impl *impl = client->impl;
 	struct pw_node_info *info = o->info;
 	struct pw_manager *manager = client->manager;
-	struct pw_manager_object *peer;
 	const char *str;
 	uint32_t module_id = SPA_ID_INVALID, client_id = SPA_ID_INVALID;
 	uint32_t peer_index;
@@ -3953,11 +4081,15 @@
 	    !volume_valid(&dev_info.volume_info.volume))
 		return -ENOENT;
 
-	peer = find_linked(manager, o->id, PW_DIRECTION_OUTPUT);
-	if (peer && pw_manager_object_is_sink(peer))
-		peer_index = peer->index;
-	else
-		peer_index = SPA_ID_INVALID;
+	peer_index = get_temporary_move_target(client, o);
+	if (peer_index == SPA_ID_INVALID) {
+		struct pw_manager_object *peer;
+		peer = find_linked(manager, o->id, PW_DIRECTION_OUTPUT);
+		if (peer && pw_manager_object_is_sink(peer))
+			peer_index = peer->index;
+		else
+			peer_index = SPA_ID_INVALID;
+	}
 
 	message_put(m,
 		TAG_U32, o->index,				/* sink_input index */
@@ -4007,7 +4139,6 @@
 	struct impl *impl = client->impl;
 	struct pw_node_info *info = o->info;
 	struct pw_manager *manager = client->manager;
-	struct pw_manager_object *peer;
 	const char *str;
 	uint32_t module_id = SPA_ID_INVALID, client_id = SPA_ID_INVALID;
 	uint32_t peer_index;
@@ -4033,11 +4164,15 @@
 	    !volume_valid(&dev_info.volume_info.volume))
 		return -ENOENT;
 
-	peer = find_linked(manager, o->id, PW_DIRECTION_INPUT);
-	if (peer && pw_manager_object_is_source_or_monitor(peer))
-		peer_index = peer->index;
-	else
-		peer_index = SPA_ID_INVALID;
+	peer_index = get_temporary_move_target(client, o);
+	if (peer_index == SPA_ID_INVALID) {
+		struct pw_manager_object *peer;
+		peer = find_linked(manager, o->id, PW_DIRECTION_INPUT);
+		if (peer && pw_manager_object_is_source_or_monitor(peer))
+			peer_index = peer->index;
+		else
+			peer_index = SPA_ID_INVALID;
+	}
 
 	message_put(m,
 		TAG_U32, o->index,				/* source_output index */
@@ -4353,7 +4488,6 @@
 	struct message *reply;
 	struct buffer_attr attr;
 	bool adjust_latency = false, early_requests = false;
-	uint64_t lat_usec;
 
 	if (message_get(m,
 			TAG_U32, &channel,
@@ -4407,7 +4541,7 @@
 	stream->early_requests = early_requests;
 
 	if (command == COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
-		lat_usec = set_playback_buffer_attr(stream, &attr);
+		stream->lat_usec = set_playback_buffer_attr(stream, &attr);
 
 		message_put(reply,
 			TAG_U32, stream->attr.maxlength,
@@ -4417,11 +4551,11 @@
 			TAG_INVALID);
 		if (client->version >= 13) {
 			message_put(reply,
-				TAG_USEC, lat_usec,		/* configured_sink_latency */
+				TAG_USEC, stream->lat_usec,		/* configured_sink_latency */
 				TAG_INVALID);
 		}
 	} else {
-		lat_usec = set_record_buffer_attr(stream, &attr);
+		stream->lat_usec = set_record_buffer_attr(stream, &attr);
 
 		message_put(reply,
 			TAG_U32, stream->attr.maxlength,
@@ -4429,7 +4563,7 @@
 			TAG_INVALID);
 		if (client->version >= 13) {
 			message_put(reply,
-				TAG_USEC, lat_usec,		/* configured_source_latency */
+				TAG_USEC, stream->lat_usec,		/* configured_source_latency */
 				TAG_INVALID);
 		}
 	}
@@ -4682,6 +4816,10 @@
 			SPA_TYPE_INFO_BASE"Id", "%"PRIi64, target_serial)) < 0)
 		return res;
 
+	/* We will temporarily claim the stream was already moved */
+	set_temporary_move_target(client, o, dev->index);
+	send_object_event(client, o, SUBSCRIPTION_EVENT_CHANGE);
+
 	return reply_simple_ack(client, tag);
 }
 
@@ -5205,6 +5343,9 @@
 	struct server *s;
 	struct client *c;
 
+	pw_map_for_each(&impl->modules, impl_unload_module, impl);
+	pw_map_clear(&impl->modules);
+
 	spa_list_consume(s, &impl->servers, link)
 		server_free(s);
 
@@ -5217,9 +5358,6 @@
 	pw_map_for_each(&impl->samples, impl_free_sample, impl);
 	pw_map_clear(&impl->samples);
 
-	pw_map_for_each(&impl->modules, impl_unload_module, impl);
-	pw_map_clear(&impl->modules);
-
 #ifdef HAVE_DBUS
 	if (impl->dbus_name) {
 		dbus_release_name(impl->dbus_name);

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/stream.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/stream.c Changed

@@ -82,6 +82,8 @@
 	stream->attr = *attr;
 	spa_ringbuffer_init(&stream->ring);
 
+	stream->peer_index = SPA_ID_INVALID;
+
 	parse_frac(client->props, "pulse.min.req", &defs->min_req, &stream->min_req);
 	parse_frac(client->props, "pulse.min.frag", &defs->min_frag, &stream->min_frag);
 	parse_frac(client->props, "pulse.min.quantum", &defs->min_quantum, &stream->min_quantum);
@@ -359,3 +361,51 @@
 	}
 	return 0;
 }
+
+int stream_send_moved(struct stream *stream, uint32_t peer_index, const char *peer_name)
+{
+	struct client *client = stream->client;
+	struct impl *impl = client->impl;
+	struct message *reply;
+	uint32_t command;
+
+	command = stream->direction == PW_DIRECTION_OUTPUT ?
+		COMMAND_PLAYBACK_STREAM_MOVED :
+		COMMAND_RECORD_STREAM_MOVED;
+
+	pw_log_info("client %p %s: stream %p %s channel:%u",
+			client, client->name, stream, commandscommand.name,
+			stream->channel);
+
+	if (client->version < 12)
+		return 0;
+
+	reply = message_alloc(impl, -1, 0);
+	message_put(reply,
+		TAG_U32, command,
+		TAG_U32, -1,
+		TAG_U32, stream->channel,
+		TAG_U32, peer_index,
+		TAG_STRING, peer_name,
+		TAG_BOOLEAN, false,		/* suspended */
+		TAG_INVALID);
+
+	if (client->version >= 13) {
+		if (command == COMMAND_PLAYBACK_STREAM_MOVED) {
+			message_put(reply,
+				TAG_U32, stream->attr.maxlength,
+				TAG_U32, stream->attr.tlength,
+				TAG_U32, stream->attr.prebuf,
+				TAG_U32, stream->attr.minreq,
+				TAG_USEC, stream->lat_usec,
+				TAG_INVALID);
+		} else {
+			message_put(reply,
+				TAG_U32, stream->attr.maxlength,
+				TAG_U32, stream->attr.fragsize,
+				TAG_USEC, stream->lat_usec,
+				TAG_INVALID);
+		}
+	}
+	return client_queue_message(client, reply);
+}

pipewire-0.3.51.tar.gz/src/modules/module-protocol-pulse/stream.h -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-pulse/stream.h Changed

pipewire-0.3.51.tar.gz/src/modules/module-protocol-simple.c -> pipewire-0.3.52.tar.gz/src/modules/module-protocol-simple.c Changed

@@ -132,7 +132,7 @@
 #define DEFAULT_SERVER " \"tcp:"SPA_STRINGIFY(DEFAULT_PORT)"\" "
 
 #define DEFAULT_FORMAT "S16"
-#define DEFAULT_RATE "44100"
+#define DEFAULT_RATE 44100
 #define DEFAULT_CHANNELS 2
 #define DEFAULT_POSITION " FL FR "
 #define DEFAULT_LATENCY "1024/44100"
@@ -143,12 +143,12 @@
 			" playback=<bool>  "						\
 			" remote.name=<remote>  "					\
 			" node.latency=<num/denom, default:"DEFAULT_LATENCY">  "	\
-			" node.rate=<1/rate, default:1/"DEFAULT_RATE">  "	\
+			" node.rate=<1/rate, default:1/"SPA_STRINGIFY(DEFAULT_RATE)">  "	\
 			" capture.node=<source-target>  stream.capture.sink=true  "	\
 			" playback.node=<sink-target>  "				\
-			" audio.rate=<sample-rate, default:"DEFAULT_RATE">  "		\
+			" audio.rate=<sample-rate, default:"SPA_STRINGIFY(DEFAULT_RATE)">  "		\
 			" audio.format=<format, default:"DEFAULT_FORMAT">  "		\
-			" audio.channels=<channels, default: 2>  "	\
+			" audio.channels=<channels, default: "SPA_STRINGIFY(DEFAULT_CHANNELS)">  "	\
 			" audio.position=<position, default:"DEFAULT_POSITION">  "	\
 			" server.address=< tcp:<ip>:<port>,... , default:"DEFAULT_SERVER">"	\
 
@@ -310,11 +310,8 @@
 	}
 	d = &buf->buffer->datas0;
 
-	size = d->chunk->size;
-	offset = d->chunk->offset;
-
-	if (size + offset > d->maxsize)
-		size = d->maxsize - SPA_MIN(offset, d->maxsize);
+	offset = SPA_MIN(d->chunk->offset, d->maxsize);
+	size = SPA_MIN(d->chunk->size, d->maxsize - offset);
 
 	while (size > 0) {
 		res = send(client->source->fd,
@@ -807,9 +804,7 @@
 		pw_log_error("invalid format '%s'", str);
 		return -EINVAL;
 	}
-	if ((str = pw_properties_get(impl->props, "audio.rate")) == NULL)
-		str = DEFAULT_RATE;
-	impl->info.rate = atoi(str);
+	impl->info.rate = pw_properties_get_uint32(impl->props, "audio.rate", DEFAULT_RATE);
 	if (impl->info.rate == 0) {
 		pw_log_error("invalid rate '%s'", str);
 		return -EINVAL;

pipewire-0.3.51.tar.gz/src/modules/module-pulse-tunnel.c -> pipewire-0.3.52.tar.gz/src/modules/module-pulse-tunnel.c Changed

@@ -68,8 +68,8 @@
  *
  * ## Module Options
  *
- * - `tunnel.mode`: the desired tunnel to create, must be `capture` or `playback`.
- *                  (Default `playback`)
+ * - `tunnel.mode`: the desired tunnel to create, must be `source` or `sink`.
+ *                  (Default `sink`)
  * - `pulse.server.address`: the address of the PulseAudio server to tunnel to.
  * - `pulse.latency`: the latency to end-to-end latency in milliseconds to
  *                    maintain (Default 200ms).
@@ -97,7 +97,7 @@
  * context.modules = 
  * {   name = libpipewire-module-pulse-tunnel
  *     args = {
- *         tunnel.mode = playback
+ *         tunnel.mode = sink
  *         # Set the remote address to tunnel to
  *         pulse.server.address = "tcp:192.168.1.126"
  *         #audio.rate=<sample rate>
@@ -128,7 +128,7 @@
 			" audio.position=<channel map>  "			\
 			"pulse.server.address=<address> "			\
 			"pulse.latency=<latency in msec> "			\
-			" tunnel.mode=capture|playback "			\
+			" tunnel.mode=source|sink "				\
 			" stream.props=<properties>  "
 
 
@@ -147,8 +147,8 @@
 struct impl {
 	struct pw_context *context;
 
-#define MODE_PLAYBACK	0
-#define MODE_CAPTURE	1
+#define MODE_SINK	0
+#define MODE_SOURCE	1
 	uint32_t mode;
 	struct pw_properties *props;
 
@@ -193,7 +193,7 @@
 	pa_threaded_mainloop_lock(impl->pa_mainloop);
 
 	pw_log_debug("corking: %d", cork);
-	if (cork && impl->mode == MODE_PLAYBACK) {
+	if (cork && impl->mode == MODE_SINK) {
 		/* When the sink becomes suspended (which is the only case where we
 		 * cork the stream), we don't want to keep any old data around, because
 		 * the old data is most likely unrelated to the audio that will be
@@ -246,7 +246,7 @@
 	struct pw_buffer *buf;
 	struct spa_data *bd;
 	int32_t filled;
-	uint32_t write_index, size;
+	uint32_t write_index, offs, size;
 
 	if ((buf = pw_stream_dequeue_buffer(impl->stream)) == NULL) {
 		pw_log_debug("out of buffers: %m");
@@ -254,7 +254,9 @@
 	}
 
 	bd = &buf->buffer->datas0;
-	size = SPA_MIN(bd->chunk->size, RINGBUFFER_SIZE);
+	offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
+	size = SPA_MIN(bd->chunk->size, bd->maxsize - offs);
+	size = SPA_MIN(size, RINGBUFFER_SIZE);
 
 	filled = spa_ringbuffer_get_write_index(&impl->ring, &write_index);
 
@@ -281,8 +283,8 @@
 	}
 	spa_ringbuffer_write_data(&impl->ring,
 				impl->buffer, RINGBUFFER_SIZE,
-                                write_index & RINGBUFFER_MASK,
-                                SPA_PTROFF(bd->data, bd->chunk->offset, void),
+				write_index & RINGBUFFER_MASK,
+				SPA_PTROFF(bd->data, offs, void),
 				size);
 	write_index += size;
 	spa_ringbuffer_write_update(&impl->ring, write_index);
@@ -376,7 +378,7 @@
 	if (impl->stream == NULL)
 		return -errno;
 
-	if (impl->mode == MODE_CAPTURE) {
+	if (impl->mode == MODE_SOURCE) {
 		pw_stream_add_listener(impl->stream,
 				&impl->stream_listener,
 				&capture_stream_events, impl);
@@ -392,14 +394,14 @@
 			SPA_PARAM_EnumFormat, &impl->info);
 
 	spa_zero(latency);
-	latency.direction = impl->mode == MODE_CAPTURE ? PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT;
+	latency.direction = impl->mode == MODE_SOURCE ? PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT;
 	latency.min_ns = latency.max_ns = impl->latency_msec * SPA_NSEC_PER_MSEC;
 
 	paramsn_params++ = spa_latency_build(&b,
 			SPA_PARAM_Latency, &latency);
 
 	if ((res = pw_stream_connect(impl->stream,
-			impl->mode == MODE_CAPTURE ? PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT,
+			impl->mode == MODE_SOURCE ? PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT,
 			PW_ID_ANY,
 			PW_STREAM_FLAG_AUTOCONNECT |
 			PW_STREAM_FLAG_MAP_BUFFERS |
@@ -665,7 +667,7 @@
 	/* half in our buffer, half in the network + remote */
 	impl->target_buffer = latency_bytes / 2;
 
-	if (impl->mode == MODE_CAPTURE) {
+	if (impl->mode == MODE_SOURCE) {
 		bufferattr.fragsize = latency_bytes / 2;
 
 		res = pa_stream_connect_record(impl->pa_stream,
@@ -931,10 +933,10 @@
 	spa_dll_init(&impl->dll);
 
 	if ((str = pw_properties_get(props, "tunnel.mode")) != NULL) {
-		if (spa_streq(str, "capture")) {
-			impl->mode = MODE_CAPTURE;
-		} else if (spa_streq(str, "playback")) {
-			impl->mode = MODE_PLAYBACK;
+		if (spa_streq(str, "source")) {
+			impl->mode = MODE_SOURCE;
+		} else if (spa_streq(str, "sink")) {
+			impl->mode = MODE_SINK;
 		} else {
 			pw_log_error("invalid tunnel.mode '%s'", str);
 			res = -EINVAL;
@@ -952,7 +954,7 @@
 
 	if (pw_properties_get(props, PW_KEY_MEDIA_CLASS) == NULL)
 		pw_properties_set(props, PW_KEY_MEDIA_CLASS,
-				impl->mode == MODE_PLAYBACK ?
+				impl->mode == MODE_SINK ?
 					"Audio/Sink" : "Audio/Source");
 
 	if ((str = pw_properties_get(props, "stream.props")) != NULL)

pipewire-0.3.51.tar.gz/src/modules/module-raop-discover.c -> pipewire-0.3.52.tar.gz/src/modules/module-raop-discover.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-raop-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-raop-sink.c Changed

@@ -101,7 +101,7 @@
 
 #define DEFAULT_FORMAT "S16"
 #define DEFAULT_RATE 44100
-#define DEFAULT_CHANNELS "2"
+#define DEFAULT_CHANNELS 2
 #define DEFAULT_POSITION " FL FR "
 
 #define DEFAULT_LATENCY (DEFAULT_RATE*2)
@@ -110,8 +110,8 @@
 			" node.name=<name of the nodes>  "					\
 			" node.description=<description of the nodes>  "			\
 			" audio.format=<format, default:"DEFAULT_FORMAT">  "			\
-			" audio.rate=<sample rate, default: 48000>  "				\
-			" audio.channels=<number of channels, default:"DEFAULT_CHANNELS">  "	\
+			" audio.rate=<sample rate, default: "SPA_STRINGIFY(DEFAuLT_RATE)">  "			\
+			" audio.channels=<number of channels, default:"SPA_STRINGIFY(DEFAULT_CHANNELS)">  "	\
 			" audio.position=<channel map, default:"DEFAULT_POSITION">  "		\
 			" stream.props=<properties>  "
 
@@ -430,7 +430,7 @@
 	struct pw_buffer *buf;
 	struct spa_data *bd;
 	uint8_t *data;
-	uint32_t size;
+	uint32_t offs, size;
 
 	if ((buf = pw_stream_dequeue_buffer(impl->stream)) == NULL) {
 		pw_log_debug("out of buffers: %m");
@@ -438,8 +438,10 @@
 	}
 
 	bd = &buf->buffer->datas0;
-	data = SPA_PTROFF(bd->data, bd->chunk->offset, uint8_t);
-	size = bd->chunk->size;
+
+	offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
+	size = SPA_MIN(bd->chunk->size, bd->maxsize - offs);
+	data = SPA_PTROFF(bd->data, offs, uint8_t);
 
 	while (size > 0 && impl->block_size > 0) {
 		uint32_t avail, to_fill;
@@ -1521,9 +1523,7 @@
 		pw_log_error("invalid rate '%s'", str);
 		return -EINVAL;
 	}
-	if ((str = pw_properties_get(props, PW_KEY_AUDIO_CHANNELS)) == NULL)
-		str = DEFAULT_CHANNELS;
-	info->channels = atoi(str);
+	info->channels = pw_properties_get_uint32(props, PW_KEY_AUDIO_CHANNELS, DEFAULT_CHANNELS);
 	if ((str = pw_properties_get(props, SPA_KEY_AUDIO_POSITION)) == NULL)
 		str = DEFAULT_POSITION;
 	parse_position(info, str, strlen(str));

pipewire-0.3.51.tar.gz/src/modules/module-roc-sink.c -> pipewire-0.3.52.tar.gz/src/modules/module-roc-sink.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/client-endpoint/client-endpoint.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/client-endpoint/client-endpoint.c Changed

@@ -38,9 +38,11 @@
 #define NAME "client-endpoint"
 
 struct factory_data {
-	struct pw_impl_factory *factory;
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
+
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
 };
 
 static struct endpoint_stream *find_stream(struct client_endpoint *this, uint32_t id)
@@ -219,12 +221,27 @@
 	.create_object = create_object,
 };
 
-static void module_destroy(void *data)
+static void factory_destroy(void *data)
 {
 	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
 
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
+static void module_destroy(void *data)
+{
+	struct factory_data *d = data;
 	spa_hook_remove(&d->module_listener);
-	pw_impl_factory_destroy(d->factory);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
@@ -271,6 +288,7 @@
 	data->module = module;
 
 	pw_impl_factory_set_implementation(factory, &impl_factory, data);
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/client-endpoint/endpoint-stream.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/client-endpoint/endpoint-stream.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/client-endpoint/endpoint.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/client-endpoint/endpoint.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/client-session/client-session.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/client-session/client-session.c Changed

@@ -38,9 +38,11 @@
 #define NAME "client-session"
 
 struct factory_data {
-	struct pw_impl_factory *factory;
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
+
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
 };
 
 static struct endpoint_link *find_link(struct client_session *this, uint32_t id)
@@ -218,12 +220,27 @@
 	.create_object = create_object,
 };
 
-static void module_destroy(void *data)
+static void factory_destroy(void *data)
 {
 	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
 
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
+static void module_destroy(void *data)
+{
+	struct factory_data *d = data;
 	spa_hook_remove(&d->module_listener);
-	pw_impl_factory_destroy(d->factory);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
@@ -270,6 +287,7 @@
 	data->module = module;
 
 	pw_impl_factory_set_implementation(factory, &impl_factory, data);
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/client-session/endpoint-link.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/client-session/endpoint-link.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/client-session/session.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/client-session/session.c Changed

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/endpoint-link.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/endpoint-link.c Changed

@@ -78,7 +78,8 @@
 
 struct factory_data
 {
-	struct pw_impl_factory *this;
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
 
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
@@ -472,7 +473,7 @@
 	pw_properties_setf(properties, PW_KEY_CLIENT_ID, "%d",
 			pw_impl_client_get_info(client)->id);
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_impl_factory_get_info(d->this)->id);
+			pw_impl_factory_get_info(d->factory)->id);
 
 	result = link_new(pw_impl_client_get_context(client), impl_resource, properties);
 	if (result == NULL) {
@@ -502,20 +503,37 @@
 	.create_object = create_object,
 };
 
+static void factory_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
+
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
 static void module_destroy(void *data)
 {
 	struct factory_data *d = data;
 
 	spa_hook_remove(&d->module_listener);
 	spa_list_remove(&d->export.link);
-	pw_impl_factory_destroy(d->this);
+	d->module = NULL;
+
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -552,7 +570,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 
 	pw_impl_factory_set_implementation(factory, &impl_factory, data);
@@ -562,10 +580,11 @@
 	if ((res = pw_context_register_export_type(context, &data->export)) < 0)
 		goto error;
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	return 0;
 error:
-	pw_impl_factory_destroy(data->this);
+	pw_impl_factory_destroy(data->factory);
 	return res;
 }

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/endpoint-stream.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/endpoint-stream.c Changed

@@ -78,11 +78,12 @@
 
 struct factory_data
 {
-	struct pw_impl_factory *this;
-
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
 
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
+
 	struct pw_export_type export;
 };
 
@@ -463,7 +464,7 @@
 	pw_properties_setf(properties, PW_KEY_CLIENT_ID, "%d",
 			pw_impl_client_get_info(client)->id);
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_impl_factory_get_info(d->this)->id);
+			pw_impl_factory_get_info(d->factory)->id);
 
 	result = stream_new(pw_impl_client_get_context(client), impl_resource, properties);
 	if (result == NULL) {
@@ -493,20 +494,37 @@
 	.create_object = create_object,
 };
 
+static void factory_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
+
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
 static void module_destroy(void *data)
 {
 	struct factory_data *d = data;
 
 	spa_hook_remove(&d->module_listener);
 	spa_list_remove(&d->export.link);
-	pw_impl_factory_destroy(d->this);
+	d->module = NULL;
+
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -543,7 +561,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 
 	pw_impl_factory_set_implementation(factory, &impl_factory, data);
@@ -553,10 +571,11 @@
 	if ((res = pw_context_register_export_type(context, &data->export)) < 0)
 		goto error;
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	return 0;
 error:
-	pw_impl_factory_destroy(data->this);
+	pw_impl_factory_destroy(data->factory);
 	return res;
 }

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/endpoint.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/endpoint.c Changed

@@ -78,11 +78,12 @@
 
 struct factory_data
 {
-	struct pw_impl_factory *this;
-
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
 
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
+
 	struct pw_export_type export;
 };
 
@@ -472,7 +473,7 @@
 	pw_properties_setf(properties, PW_KEY_CLIENT_ID, "%d",
 			pw_impl_client_get_info(client)->id);
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_impl_factory_get_info(d->this)->id);
+			pw_impl_factory_get_info(d->factory)->id);
 
 	result = endpoint_new(pw_impl_client_get_context(client), impl_resource, properties);
 	if (result == NULL) {
@@ -502,20 +503,37 @@
 	.create_object = create_object,
 };
 
+static void factory_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
+
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
 static void module_destroy(void *data)
 {
 	struct factory_data *d = data;
 
 	spa_hook_remove(&d->module_listener);
 	spa_list_remove(&d->export.link);
-	pw_impl_factory_destroy(d->this);
+
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -552,7 +570,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 
 	pw_impl_factory_set_implementation(factory, &impl_factory, data);
@@ -562,10 +580,11 @@
 	if ((res = pw_context_register_export_type(context, &data->export)) < 0)
 		goto error;
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	return 0;
 error:
-	pw_impl_factory_destroy(data->this);
+	pw_impl_factory_destroy(data->factory);
 	return res;
 }

pipewire-0.3.51.tar.gz/src/modules/module-session-manager/session.c -> pipewire-0.3.52.tar.gz/src/modules/module-session-manager/session.c Changed

@@ -78,11 +78,12 @@
 
 struct factory_data
 {
-	struct pw_impl_factory *this;
-
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
 
+	struct pw_impl_factory *factory;
+	struct spa_hook factory_listener;
+
 	struct pw_export_type export;
 };
 
@@ -461,7 +462,7 @@
 	pw_properties_setf(properties, PW_KEY_CLIENT_ID, "%d",
 			pw_impl_client_get_info(client)->id);
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_impl_factory_get_info(d->this)->id);
+			pw_impl_factory_get_info(d->factory)->id);
 
 	result = session_new(pw_impl_client_get_context(client), impl_resource, properties);
 	if (result == NULL) {
@@ -491,20 +492,36 @@
 	.create_object = create_object,
 };
 
+static void factory_destroy(void *data)
+{
+	struct factory_data *d = data;
+	spa_hook_remove(&d->factory_listener);
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
+}
+
+static const struct pw_impl_factory_events factory_events = {
+	PW_VERSION_IMPL_FACTORY_EVENTS,
+	.destroy = factory_destroy,
+};
+
 static void module_destroy(void *data)
 {
 	struct factory_data *d = data;
 
 	spa_hook_remove(&d->module_listener);
 	spa_list_remove(&d->export.link);
-	pw_impl_factory_destroy(d->this);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -541,7 +558,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 
 	pw_impl_factory_set_implementation(factory, &impl_factory, data);
@@ -551,10 +568,11 @@
 	if ((res = pw_context_register_export_type(context, &data->export)) < 0)
 		goto error;
 
+	pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data);
 	pw_impl_module_add_listener(module, &data->module_listener, &module_events, data);
 
 	return 0;
 error:
-	pw_impl_factory_destroy(data->this);
+	pw_impl_factory_destroy(data->factory);
 	return res;
 }

pipewire-0.3.51.tar.gz/src/modules/module-zeroconf-discover.c -> pipewire-0.3.52.tar.gz/src/modules/module-zeroconf-discover.c Changed

pipewire-0.3.51.tar.gz/src/modules/spa/module-device-factory.c -> pipewire-0.3.52.tar.gz/src/modules/spa/module-device-factory.c Changed

@@ -51,11 +51,12 @@
 
 struct factory_data {
 	struct pw_context *context;
+
 	struct pw_impl_module *module;
-	struct pw_impl_factory *this;
+	struct spa_hook module_listener;
 
+	struct pw_impl_factory *factory;
 	struct spa_hook factory_listener;
-	struct spa_hook module_listener;
 
 	struct spa_list device_list;
 };
@@ -120,7 +121,7 @@
 		goto error_properties;
 
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_global_get_id(pw_impl_factory_get_global(data->this)));
+			pw_global_get_id(pw_impl_factory_get_global(data->factory)));
 
 	client = resource ? pw_resource_get_client(resource) : NULL;
 
@@ -190,16 +191,19 @@
 	.create_object = create_object,
 };
 
-static void factory_destroy(void *_data)
+static void factory_destroy(void *data)
 {
-	struct factory_data *data = _data;
+	struct factory_data *d = data;
 	struct device_data *nd;
 
-	spa_hook_remove(&data->factory_listener);
-	spa_hook_remove(&data->module_listener);
+	spa_hook_remove(&d->factory_listener);
 
-	spa_list_consume(nd, &data->device_list, link)
+	spa_list_consume(nd, &d->device_list, link)
 		pw_impl_device_destroy(nd->device);
+
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
 }
 
 static const struct pw_impl_factory_events factory_events = {
@@ -207,17 +211,21 @@
 	.destroy = factory_destroy,
 };
 
-static void module_destroy(void *_data)
+static void module_destroy(void *data)
 {
-	struct factory_data *data = _data;
-	pw_impl_factory_destroy(data->this);
+	struct factory_data *d = data;
+
+	spa_hook_remove(&d->module_listener);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -256,7 +264,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->module = module;
 	data->context = context;
 	spa_list_init(&data->device_list);

pipewire-0.3.51.tar.gz/src/modules/spa/module-node-factory.c -> pipewire-0.3.52.tar.gz/src/modules/spa/module-node-factory.c Changed

@@ -51,11 +51,12 @@
 
 struct factory_data {
 	struct pw_context *context;
-	struct pw_impl_factory *this;
+
 	struct pw_impl_module *module;
+	struct spa_hook module_listener;
 
+	struct pw_impl_factory *factory;
 	struct spa_hook factory_listener;
-	struct spa_hook module_listener;
 
 	struct spa_list node_list;
 };
@@ -65,6 +66,7 @@
 	struct spa_list link;
 	struct pw_impl_node *node;
 	struct spa_hook node_listener;
+	struct pw_resource *resource;
 	struct spa_hook resource_listener;
 	unsigned int linger:1;
 };
@@ -74,6 +76,7 @@
 	struct node_data *nd = data;
 	pw_log_debug("node %p", nd);
 	spa_hook_remove(&nd->resource_listener);
+	nd->resource = NULL;
 	if (nd->node && !nd->linger)
 		pw_impl_node_destroy(nd->node);
 }
@@ -90,6 +93,11 @@
 	spa_list_remove(&nd->link);
 	spa_hook_remove(&nd->node_listener);
 	nd->node = NULL;
+
+	if (nd->resource) {
+		spa_hook_remove(&nd->resource_listener);
+		nd->resource = NULL;
+	}
 }
 
 static const struct pw_impl_node_events node_events = {
@@ -121,7 +129,7 @@
 		goto error_properties;
 
 	pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d",
-			pw_global_get_id(pw_impl_factory_get_global(data->this)));
+			pw_global_get_id(pw_impl_factory_get_global(data->factory)));
 
 	linger = pw_properties_get_bool(properties, PW_KEY_OBJECT_LINGER, false);
 
@@ -147,17 +155,15 @@
 	pw_impl_node_add_listener(node, &nd->node_listener, &node_events, nd);
 
 	if (client) {
-		struct pw_resource *bound_resource;
-
 		res = pw_global_bind(pw_impl_node_get_global(node),
 			       client, PW_PERM_ALL, version, new_id);
 		if (res < 0)
 			goto error_bind;
 
-		if ((bound_resource = pw_impl_client_find_resource(client, new_id)) == NULL)
+		if ((nd->resource = pw_impl_client_find_resource(client, new_id)) == NULL)
 			goto error_bind;
 
-		pw_resource_add_listener(bound_resource, &nd->resource_listener, &resource_events, nd);
+		pw_resource_add_listener(nd->resource, &nd->resource_listener, &resource_events, nd);
 	}
 	return node;
 
@@ -187,15 +193,17 @@
 	.create_object = create_object,
 };
 
-static void factory_destroy(void *_data)
+static void factory_destroy(void *data)
 {
-	struct factory_data *data = _data;
+	struct factory_data *d = data;
 	struct node_data *nd;
 
-	spa_hook_remove(&data->factory_listener);
-	spa_list_consume(nd, &data->node_list, link)
+	spa_hook_remove(&d->factory_listener);
+	spa_list_consume(nd, &d->node_list, link)
 		pw_impl_node_destroy(nd->node);
-	data->this = NULL;
+	d->factory = NULL;
+	if (d->module)
+		pw_impl_module_destroy(d->module);
 }
 
 static const struct pw_impl_factory_events factory_events = {
@@ -203,19 +211,20 @@
 	.destroy = factory_destroy,
 };
 
-static void module_destroy(void *_data)
+static void module_destroy(void *data)
 {
-	struct factory_data *data = _data;
-	spa_hook_remove(&data->module_listener);
-	if (data->this)
-		pw_impl_factory_destroy(data->this);
+	struct factory_data *d = data;
+	spa_hook_remove(&d->module_listener);
+	d->module = NULL;
+	if (d->factory)
+		pw_impl_factory_destroy(d->factory);
 }
 
 static void module_registered(void *data)
 {
 	struct factory_data *d = data;
 	struct pw_impl_module *module = d->module;
-	struct pw_impl_factory *factory = d->this;
+	struct pw_impl_factory *factory = d->factory;
 	struct spa_dict_item items1;
 	char id16;
 	int res;
@@ -254,7 +263,7 @@
 		return -errno;
 
 	data = pw_impl_factory_get_user_data(factory);
-	data->this = factory;
+	data->factory = factory;
 	data->context = context;
 	data->module = module;
 	spa_list_init(&data->node_list);

pipewire-0.3.51.tar.gz/src/pipewire/impl-client.c -> pipewire-0.3.52.tar.gz/src/pipewire/impl-client.c Changed

@@ -24,6 +24,7 @@
 
 #include <errno.h>
 #include <string.h>
+#include <assert.h>
 
 #include <spa/utils/string.h>
 
@@ -415,6 +416,7 @@
 	this = &impl->this;
 	pw_log_debug("%p: new", this);
 
+	this->refcount = 1;
 	this->context = core->context;
 	this->core = core;
 	this->protocol = protocol;
@@ -584,6 +586,33 @@
 }
 
 
+SPA_EXPORT
+void pw_impl_client_unref(struct pw_impl_client *client)
+{
+	struct impl *impl = SPA_CONTAINER_OF(client, struct impl, this);
+
+	assert(client->refcount > 0);
+	if (--client->refcount > 0)
+		return;
+
+	pw_log_debug("%p: free", impl);
+	assert(client->destroyed);
+
+	pw_impl_client_emit_free(client);
+
+	spa_hook_list_clean(&client->listener_list);
+
+	pw_map_clear(&client->objects);
+	pw_array_clear(&impl->permissions);
+
+	spa_hook_remove(&impl->pool_listener);
+	pw_mempool_destroy(client->pool);
+
+	pw_properties_free(client->properties);
+
+	free(impl);
+}
+
 /** Destroy a client object
  *
  * \param client the client to destroy
@@ -595,6 +624,10 @@
 	struct impl *impl = SPA_CONTAINER_OF(client, struct impl, this);
 
 	pw_log_debug("%p: destroy", client);
+
+	assert(!client->destroyed);
+	client->destroyed = true;
+
 	pw_impl_client_emit_destroy(client);
 
 	spa_hook_remove(&impl->context_listener);
@@ -609,20 +642,7 @@
 		pw_global_destroy(client->global);
 	}
 
-	pw_log_debug("%p: free", impl);
-	pw_impl_client_emit_free(client);
-
-	spa_hook_list_clean(&client->listener_list);
-
-	pw_map_clear(&client->objects);
-	pw_array_clear(&impl->permissions);
-
-	spa_hook_remove(&impl->pool_listener);
-	pw_mempool_destroy(client->pool);
-
-	pw_properties_free(client->properties);
-
-	free(impl);
+	pw_impl_client_unref(client);
 }
 
 SPA_EXPORT

pipewire-0.3.51.tar.gz/src/pipewire/impl-module.c -> pipewire-0.3.52.tar.gz/src/pipewire/impl-module.c Changed

pipewire-0.3.51.tar.gz/src/pipewire/impl-port.c -> pipewire-0.3.52.tar.gz/src/pipewire/impl-port.c Changed

pipewire-0.3.51.tar.gz/src/pipewire/introspect.c -> pipewire-0.3.52.tar.gz/src/pipewire/introspect.c Changed

pipewire-0.3.51.tar.gz/src/pipewire/pipewire.c -> pipewire-0.3.52.tar.gz/src/pipewire/pipewire.c Changed

pipewire-0.3.51.tar.gz/src/pipewire/private.h -> pipewire-0.3.52.tar.gz/src/pipewire/private.h Changed

pipewire-0.3.51.tar.gz/src/pipewire/resource.c -> pipewire-0.3.52.tar.gz/src/pipewire/resource.c Changed

@@ -23,6 +23,7 @@
  */
 
 #include <string.h>
+#include <assert.h>
 
 #include "pipewire/private.h"
 #include "pipewire/protocol.h"
@@ -57,6 +58,7 @@
 		return NULL;
 
 	this = &impl->this;
+	this->refcount = 1;
 	this->context = client->context;
 	this->client = client;
 	this->permissions = permissions;
@@ -279,16 +281,57 @@
 }
 
 SPA_EXPORT
+void pw_resource_ref(struct pw_resource *resource)
+{
+	assert(resource->refcount > 0);
+	resource->refcount++;
+}
+
+SPA_EXPORT
+void pw_resource_unref(struct pw_resource *resource)
+{
+	assert(resource->refcount > 0);
+	if (--resource->refcount > 0)
+		return;
+
+	pw_log_debug("%p: free %u", resource, resource->id);
+	assert(resource->destroyed);
+
+#if DEBUG_LISTENERS
+	{
+		struct spa_hook *h;
+		spa_list_for_each(h, &resource->object_listener_list.list, link) {
+			pw_log_warn("%p: resource %u: leaked object listener %p",
+					resource, resource->id, h);
+			break;
+		}
+		spa_list_for_each(h, &resource->listener_list.list, link) {
+			pw_log_warn("%p: resource %u: leaked listener %p",
+					resource, resource->id, h);
+			break;
+		}
+	}
+#endif
+	spa_hook_list_clean(&resource->listener_list);
+	spa_hook_list_clean(&resource->object_listener_list);
+
+	free(resource);
+}
+
+SPA_EXPORT
 void pw_resource_destroy(struct pw_resource *resource)
 {
 	struct pw_impl_client *client = resource->client;
 
+	pw_log_debug("%p: destroy %u", resource, resource->id);
+	assert(!resource->destroyed);
+	resource->destroyed = true;
+
 	if (resource->global) {
 		spa_list_remove(&resource->link);
 		resource->global = NULL;
 	}
 
-	pw_log_debug("%p: destroy %u", resource, resource->id);
 	pw_resource_emit_destroy(resource);
 
 	pw_map_insert_at(&client->objects, resource->id, NULL);
@@ -297,12 +340,7 @@
 	if (client->core_resource && !resource->removed)
 		pw_core_resource_remove_id(client->core_resource, resource->id);
 
-	pw_log_debug("%p: free %u", resource, resource->id);
-
-	spa_hook_list_clean(&resource->listener_list);
-	spa_hook_list_clean(&resource->object_listener_list);
-
-	free(resource);
+	pw_resource_unref(resource);
 }
 
 SPA_EXPORT

pipewire-0.3.51.tar.gz/src/pipewire/resource.h -> pipewire-0.3.52.tar.gz/src/pipewire/resource.h Changed

pipewire-0.3.51.tar.gz/src/pipewire/settings.c -> pipewire-0.3.52.tar.gz/src/pipewire/settings.c Changed

@@ -41,6 +41,7 @@
 #define NAME "settings"
 
 #define DEFAULT_CLOCK_RATE			48000u
+#define DEFAULT_CLOCK_RATES			" 44100 48000 "
 #define DEFAULT_CLOCK_QUANTUM			1024u
 #define DEFAULT_CLOCK_MIN_QUANTUM		32u
 #define DEFAULT_CLOCK_MAX_QUANTUM		2048u
@@ -126,16 +127,18 @@
 }
 
 static uint32_t parse_clock_rate(struct pw_properties *properties, const char *name,
-		uint32_t *rates, uint32_t def)
+		uint32_t *rates, const char *def_rates, uint32_t def)
 {
 	const char *str;
 	uint32_t count = 0;
 
 	if ((str = pw_properties_get(properties, name)) == NULL)
-		return 0;
+		str = def_rates;
 
 	count = parse_uint32_array(str, rates, MAX_RATES, def);
 	if (count == 0)
+		count = parse_uint32_array(def_rates, rates, MAX_RATES, def);
+	if (count == 0)
 		goto fallback;
 
 	return count;
@@ -223,7 +226,8 @@
 	struct settings *d = &this->defaults;
 
 	d->clock_rate = get_default_int(p, "default.clock.rate", DEFAULT_CLOCK_RATE);
-	d->n_clock_rates = parse_clock_rate(p, "default.clock.allowed-rates", d->clock_rates, d->clock_rate);
+	d->n_clock_rates = parse_clock_rate(p, "default.clock.allowed-rates", d->clock_rates,
+			DEFAULT_CLOCK_RATES, d->clock_rate);
 	d->clock_quantum = get_default_int(p, "default.clock.quantum", DEFAULT_CLOCK_QUANTUM);
 	d->clock_min_quantum = get_default_int(p, "default.clock.min-quantum", DEFAULT_CLOCK_MIN_QUANTUM);
 	d->clock_max_quantum = get_default_int(p, "default.clock.max-quantum", DEFAULT_CLOCK_MAX_QUANTUM);

pipewire-0.3.51.tar.gz/src/pipewire/stream.c -> pipewire-0.3.52.tar.gz/src/pipewire/stream.c Changed

@@ -172,6 +172,7 @@
 	unsigned int driving:1;
 	unsigned int using_trigger:1;
 	unsigned int trigger:1;
+	int in_set_control;
 };
 
 static int get_param_index(uint32_t id)
@@ -543,7 +544,9 @@
 	if (id != SPA_PARAM_Props)
 		return -ENOTSUP;
 
-	pw_stream_emit_param_changed(stream, id, param);
+	if (impl->in_set_control == 0)
+		pw_stream_emit_param_changed(stream, id, param);
+
 	return 0;
 }
 
@@ -1771,7 +1774,6 @@
 	struct stream *impl = SPA_CONTAINER_OF(stream, struct stream, this);
 	struct pw_impl_factory *factory;
 	struct pw_properties *props = NULL;
-	struct pw_impl_node *follower;
 	const char *str;
 	uint32_t i;
 	int res;
@@ -1920,14 +1922,6 @@
 		pw_properties_set(props, "channelmix.normalize", "true");
 	}
 
-	follower = pw_context_create_node(impl->context, pw_properties_copy(props), 0);
-	if (follower == NULL) {
-		res = -errno;
-		goto error_node;
-	}
-
-	pw_impl_node_set_implementation(follower, &impl->impl_node);
-
 	if (impl->media_type == SPA_MEDIA_TYPE_audio) {
 		factory = pw_context_find_factory(impl->context, "adapter");
 		if (factory == NULL) {
@@ -1935,7 +1929,8 @@
 			res = -ENOENT;
 			goto error_node;
 		}
-		pw_properties_setf(props, "adapt.follower.node", "pointer:%p", follower);
+		pw_properties_setf(props, "adapt.follower.spa-node", "pointer:%p",
+				&impl->impl_node);
 		pw_properties_set(props, "object.register", "false");
 		impl->node = pw_impl_factory_create_object(factory,
 				NULL,
@@ -1949,9 +1944,13 @@
 			goto error_node;
 		}
 	} else {
-		impl->node = follower;
-		pw_properties_free(props);
+		impl->node = pw_context_create_node(impl->context, props, 0);
 		props = NULL;
+		if (impl->node == NULL) {
+			res = -errno;
+			goto error_node;
+		}
+		pw_impl_node_set_implementation(impl->node, &impl->impl_node);
 	}
 	pw_impl_node_set_active(impl->node,
 			!SPA_FLAG_IS_SET(impl->flags, PW_STREAM_FLAG_INACTIVE));
@@ -2078,6 +2077,9 @@
 	struct spa_pod *pod;
 	struct control *c;
 
+	if (impl->node == NULL)
+		return -EIO;
+
 	va_start(varargs, values);
 
 	spa_pod_builder_push_object(&b, &f0, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props);
@@ -2117,7 +2119,9 @@
 
 	va_end(varargs);
 
+	impl->in_set_control++;
 	pw_impl_node_set_param(impl->node, SPA_PARAM_Props, 0, pod);
+	impl->in_set_control--;
 
 	return 0;
 }

pipewire-0.3.51.tar.gz/src/pipewire/stream.h -> pipewire-0.3.52.tar.gz/src/pipewire/stream.h Changed

@@ -50,6 +50,14 @@
  * inputs and/or outputs you will need to use the pw_filter or make
  * a pw_node yourself and export it with \ref pw_core_export.
  *
+ * Streams can also be used to:
+ *
+ * \li Implement a Sink in PipeWire. This is a PW_DIRECTION_INPUT stream.
+ * \li Implement a Source in PipeWire. This is a PW_DIRECTION_OUTPUT stream
+ *
+ * In this case, the PW_KEY_MEDIA_CLASS property needs to be set to
+ * "Audio/Sink" or "Audio/Source" respectively.
+ *
  * \section sec_create Create
  *
  * Make a new stream with \ref pw_stream_new(). You will need to specify
@@ -64,6 +72,16 @@
  * The stream is initially unconnected. To connect the stream, use
  * \ref pw_stream_connect(). Pass the desired direction as an argument.
  *
+ * The direction is:
+
+ * \li PW_DIRECTION_INPUT for a stream that *consumes* data. This can be a
+ * stream that captures from a Source or a when the stream is used to
+ * implement a Sink.
+ *
+ * \li PW_DIRECTION_OUTPUT for a stream that *produces* data. This can be a
+ * stream that plays to a Sink or when the stream is used to implement
+ * a Source.
+ *
  * \subsection ssec_stream_target Stream target
  *
  * To make the newly connected stream automatically connect to an existing

pipewire-0.3.51.tar.gz/src/pipewire/utils.c -> pipewire-0.3.52.tar.gz/src/pipewire/utils.c Changed

pipewire-0.3.51.tar.gz/src/pipewire/utils.h -> pipewire-0.3.52.tar.gz/src/pipewire/utils.h Changed

pipewire-0.3.51.tar.gz/src/tools/dsffile.c -> pipewire-0.3.52.tar.gz/src/tools/dsffile.c Changed

pipewire-0.3.51.tar.gz/src/tools/pw-cat.c -> pipewire-0.3.52.tar.gz/src/tools/pw-cat.c Changed

@@ -709,10 +709,11 @@
 	data->stride = data->dsf.layout.channels * SPA_ABS(data->dsf.layout.interleave);
 
 	if (data->verbose) {
-		printf("DSD: channels:%d bitorder:%s interleave:%d\n",
+		printf("DSD: channels:%d bitorder:%s interleave:%d stride:%d\n",
 				data->dsf.layout.channels,
 				data->dsf.layout.lsb ? "lsb" : "msb",
-				data->dsf.layout.interleave);
+				data->dsf.layout.interleave,
+				data->stride);
 	}
 }
 
@@ -849,6 +850,7 @@
 	{ "media-role",		required_argument, NULL, OPT_MEDIA_ROLE },
 	{ "target",		required_argument, NULL, OPT_TARGET },
 	{ "latency",		required_argument, NULL, OPT_LATENCY },
+	{ "properties",		required_argument, NULL, 'P' },
 
 	{ "rate",		required_argument, NULL, OPT_RATE },
 	{ "channels",		required_argument, NULL, OPT_CHANNELS },
@@ -867,7 +869,7 @@
 	fp = is_error ? stderr : stdout;
 
         fprintf(fp,
-	   _("%s options <file>\n"
+	   _("%s options <file>|-\n"
              "  -h, --help                            Show this help\n"
              "      --version                         Show version\n"
              "  -v, --verbose                         Enable verbose operations\n"
@@ -884,6 +886,7 @@
 	     "                                          Xunit (unit = s, ms, us, ns)\n"
 	     "                                          or direct samples (256)\n"
 	     "                                          the rate is the one of the source file\n"
+	     "  -P  --properties                      Set node properties\n"
 	     "\n"),
 	     DEFAULT_MEDIA_TYPE,
 	     DEFAULT_MEDIA_CATEGORY_PLAYBACK,
@@ -1073,6 +1076,62 @@
 	return 0;
 }
 
+struct format_info {
+	const char *name;
+	uint32_t spa_format;
+	uint32_t width;
+} format_info = {
+	{  "s8", SPA_AUDIO_FORMAT_S8, 1 },
+	{  "u8", SPA_AUDIO_FORMAT_U8, 1 },
+	{  "s16", SPA_AUDIO_FORMAT_S16, 2 },
+	{  "s24", SPA_AUDIO_FORMAT_S24, 3 },
+	{  "s32", SPA_AUDIO_FORMAT_S32, 4 },
+	{  "f32", SPA_AUDIO_FORMAT_F32, 4 },
+	{  "f64", SPA_AUDIO_FORMAT_F32, 8 },
+};
+
+static struct format_info *format_info_by_name(const char *str)
+{
+	uint32_t i;
+	for (i = 0; i < SPA_N_ELEMENTS(format_info); i++)
+		if (spa_streq(str, format_infoi.name))
+			return &format_infoi;
+	return NULL;
+}
+
+static int stdout_record(struct data *d, void *src, unsigned int n_frames)
+{
+	return fwrite(src, d->stride, n_frames, stdout);
+}
+
+static int stdin_play(struct data *d, void *src, unsigned int n_frames)
+{
+	return fread(src, d->stride, n_frames, stdin);
+}
+
+static int setup_pipe(struct data *data)
+{
+	struct format_info *info;
+
+	if (data->format == NULL)
+		data->format = DEFAULT_FORMAT;
+	if (data->channels == 0)
+		data->channels = DEFAULT_CHANNELS;
+	if (data->rate == 0)
+		data->rate = DEFAULT_RATE;
+	if (data->channelmap.n_channels == 0)
+		channelmap_default(&data->channelmap, data->channels);
+
+	info = format_info_by_name(data->format);
+	if (info == NULL)
+		return -EINVAL;
+
+	data->spa_format = info->spa_format;
+	data->stride = info->width * data->channels;
+	data->fill = data->mode == mode_playback ?  stdin_play : stdout_record;
+	return 0;
+}
+
 static int fill_properties(struct data *data)
 {
 	static const char * const table = {
@@ -1350,8 +1409,17 @@
 	/* negative means no volume adjustment */
 	data.volume = -1.0;
 	data.quality = -1;
+	data.props = pw_properties_new(
+			PW_KEY_APP_NAME, prog,
+			PW_KEY_NODE_NAME, prog,
+			NULL);
 
-	while ((c = getopt_long(argc, argv, "hvprmdR:q:", long_options, NULL)) != -1) {
+	if (data.props == NULL) {
+		fprintf(stderr, "error: pw_properties_new() failed: %m\n");
+		goto error_no_props;
+	}
+
+	while ((c = getopt_long(argc, argv, "hvprmdR:q:P:", long_options, NULL)) != -1) {
 
 		switch (c) {
 
@@ -1408,6 +1476,10 @@
 			data.media_role = optarg;
 			break;
 
+		case 'P':
+			pw_properties_update_string(data.props, optarg, strlen(optarg));
+			break;
+
 		case OPT_TARGET:
 			data.target = optarg;
 			if (spa_streq(data.target, "0")) {
@@ -1499,26 +1571,17 @@
 		data.volume = DEFAULT_VOLUME;
 
 	if (optind >= argc) {
-		fprintf(stderr, "error: filename argument missing\n");
+		fprintf(stderr, "error: filename or - argument missing\n");
 		goto error_usage;
 	}
 	data.filename = argvoptind++;
 
-	data.props = pw_properties_new(
-			PW_KEY_MEDIA_TYPE, data.media_type,
-			PW_KEY_MEDIA_CATEGORY, data.media_category,
-			PW_KEY_MEDIA_ROLE, data.media_role,
-			PW_KEY_APP_NAME, prog,
-			PW_KEY_MEDIA_FILENAME, data.filename,
-			PW_KEY_MEDIA_NAME, data.filename,
-			PW_KEY_NODE_NAME, prog,
-			PW_KEY_TARGET_OBJECT, data.target,
-			NULL);
-
-	if (data.props == NULL) {
-		fprintf(stderr, "error: pw_properties_new() failed: %m\n");
-		goto error_no_props;
-	}
+	pw_properties_set(data.props, PW_KEY_MEDIA_TYPE, data.media_type);
+	pw_properties_set(data.props, PW_KEY_MEDIA_CATEGORY, data.media_category);
+	pw_properties_set(data.props, PW_KEY_MEDIA_ROLE, data.media_role);
+	pw_properties_set(data.props, PW_KEY_MEDIA_FILENAME, data.filename);
+	pw_properties_set(data.props, PW_KEY_MEDIA_NAME, data.filename);
+	pw_properties_set(data.props, PW_KEY_TARGET_OBJECT, data.target);
 
 	/* make a main loop. If you already have another main loop, you can add
 	 * the fd of this pipewire mainloop to it. */
@@ -1553,19 +1616,23 @@
 	}
 	pw_core_add_listener(data.core, &data.core_listener, &core_events, &data);
 
-	switch (data.data_type) {
-	case TYPE_PCM:
-		ret = setup_sndfile(&data);
-		break;
-	case TYPE_MIDI:
-		ret = setup_midifile(&data);
-		break;
-	case TYPE_DSD:
-		ret = setup_dsffile(&data);
-		break;
-	default:
-		ret = -ENOTSUP;
-		break;
+	if (spa_streq(data.filename, "-")) {
+		ret = setup_pipe(&data);
+	} else {
+		switch (data.data_type) {
+		case TYPE_PCM:
+			ret = setup_sndfile(&data);
+			break;
+		case TYPE_MIDI:
+			ret = setup_midifile(&data);
+			break;
+		case TYPE_DSD:
+			ret = setup_dsffile(&data);
+			break;
+		default:
+			ret = -ENOTSUP;
+			break;
+		}
 	}
 
 	if (ret < 0) {

pipewire-0.3.51.tar.gz/src/tools/pw-dump.c -> pipewire-0.3.52.tar.gz/src/tools/pw-dump.c Changed

@@ -1332,23 +1332,6 @@
 	return;
 }
 
-static void registry_event_global_remove(void *data, uint32_t id)
-{
-	struct data *d = data;
-	struct object *o;
-
-	if ((o = find_object(d, id)) == NULL)
-		return;
-
-	object_destroy(o);
-}
-
-static const struct pw_registry_events registry_events = {
-	PW_VERSION_REGISTRY_EVENTS,
-	.global = registry_event_global,
-	.global_remove = registry_event_global_remove,
-};
-
 static bool object_matches(struct object *o, const char *pattern)
 {
 	uint32_t id;
@@ -1375,6 +1358,38 @@
 	return false;
 }
 
+static void registry_event_global_remove(void *data, uint32_t id)
+{
+	struct data *d = data;
+	struct object *o;
+
+	if ((o = find_object(d, id)) == NULL)
+		return;
+
+	d->state = STATE_FIRST;
+	if (d->pattern != NULL && !object_matches(o, d->pattern))
+		return;
+	if (d->state == STATE_FIRST)
+		put_begin(d, NULL, "", 0);
+	put_begin(d, NULL, "{", 0);
+	put_int(d, "id", o->id);
+	if (o->class && o->class->dump)
+		put_value(d, "info", NULL);
+	else if (o->props)
+		put_value(d, "props", NULL);
+	put_end(d, "}", 0);
+	if (d->state != STATE_FIRST)
+		put_end(d, "\n", 0);
+
+	object_destroy(o);
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+	.global_remove = registry_event_global_remove,
+};
+
 static void dump_objects(struct data *d)
 {
 	static const struct flags_info fl = {

pipewire-0.3.51.tar.gz/src/tools/pw-loopback.c -> pipewire-0.3.52.tar.gz/src/tools/pw-loopback.c Changed

@@ -51,6 +51,7 @@
 	struct pw_impl_module *module;
 	struct spa_hook module_listener;
 
+	const char *opt_node_name;
 	const char *opt_group_name;
 	const char *opt_channel_map;
 
@@ -87,6 +88,7 @@
 		"  -h, --help                            Show this help\n"
 		"      --version                         Show version\n"
 		"  -r, --remote                          Remote daemon name\n"
+		"  -n, --name                            Node name (default '%s')\n"
 		"  -g, --group                           Node group (default '%s')\n"
 		"  -c, --channels                        Number of channels (default %d)\n"
 		"  -m, --channel-map                     Channel map (default '%s')\n"
@@ -96,6 +98,7 @@
 		"  -P  --playback                        Playback sink to connect to\n"
 		"      --playback-props                  Playback stream properties\n",
 		name,
+		data->opt_node_name,
 		data->opt_group_name,
 		data->channels,
 		data->opt_channel_map);
@@ -115,6 +118,7 @@
 		{ "version",		no_argument,		NULL, 'V' },
 		{ "remote",		required_argument,	NULL, 'r' },
 		{ "group",		required_argument,	NULL, 'g' },
+		{ "name",		required_argument,	NULL, 'n' },
 		{ "channels",		required_argument,	NULL, 'c' },
 		{ "latency",		required_argument,	NULL, 'l' },
 		{ "capture",		required_argument,	NULL, 'C' },
@@ -133,6 +137,7 @@
 	data.opt_group_name = pw_get_client_name();
 	if (snprintf(cname, sizeof(cname), "%s-%zd", argv0, (size_t) getpid()) > 0)
 		data.opt_group_name = cname;
+	data.opt_node_name = data.opt_group_name;
 
 	data.capture_props = pw_properties_new(NULL, NULL);
 	data.playback_props = pw_properties_new(NULL, NULL);
@@ -141,7 +146,7 @@
 		goto exit;
 	}
 
-	while ((c = getopt_long(argc, argv, "hVr:g:c:m:l:C:P:i:o:", long_options, NULL)) != -1) {
+	while ((c = getopt_long(argc, argv, "hVr:n:g:c:m:l:C:P:i:o:", long_options, NULL)) != -1) {
 		switch (c) {
 		case 'h':
 			show_help(&data, argv0, false);
@@ -157,6 +162,9 @@
 		case 'r':
 			opt_remote = optarg;
 			break;
+		case 'n':
+			data.opt_node_name = optarg;
+			break;
 		case 'g':
 			data.opt_group_name = optarg;
 			break;
@@ -219,6 +227,8 @@
 		fprintf(f, " audio.channels = %u", data.channels);
 	if (data.opt_channel_map != NULL)
 		fprintf(f, " audio.position = %s", data.opt_channel_map);
+	if (data.opt_node_name != NULL)
+		fprintf(f, " node.name = %s", data.opt_node_name);
 
 	if (data.opt_group_name != NULL) {
 		pw_properties_set(data.capture_props, PW_KEY_NODE_GROUP, data.opt_group_name);

pipewire-0.3.51.tar.gz/test/test-loop.c -> pipewire-0.3.52.tar.gz/test/test-loop.c Changed

@@ -374,6 +374,82 @@
 	return PWTEST_PASS;
 }
 
+struct ctwd_data {
+	struct spa_source source;
+	int handler_running_barrier;
+};
+
+static void ctwd_event_handler(struct spa_source *source)
+{
+	struct ctwd_data *data = source->data;
+
+	write_eventfd(data->handler_running_barrier);
+
+	for (;;)
+		pause(); /* the purpose of this is to block the loop */
+}
+
+static int ctwd_add_source(struct spa_loop *loop, bool async, uint32_t seq,
+			   const void *d, size_t size, void *user_data)
+{
+	struct ctwd_data *data = user_data;
+
+	pwtest_neg_errno_ok(spa_loop_add_source(loop, &data->source));
+
+	return 0;
+}
+
+PWTEST(cancel_thread_while_dispatching)
+{
+	static const struct spa_dict_item data_loop_props_items = {
+		{ "loop.cancel", "true" },
+	};
+	static const struct spa_dict data_loop_props = SPA_DICT_INIT_ARRAY(data_loop_props_items);
+
+	struct ctwd_data data = {
+		.source = {
+			.data = &data,
+			.func = ctwd_event_handler,
+			.mask = SPA_IO_IN,
+			.fd = eventfd(0, 0),
+		},
+		.handler_running_barrier = eventfd(0, 0),
+	};
+
+	pw_init(NULL, NULL);
+
+	struct pw_data_loop *dl = pw_data_loop_new(&data_loop_props);
+	pwtest_ptr_notnull(dl);
+
+	struct pw_loop *l = pw_data_loop_get_loop(dl);
+	pwtest_ptr_notnull(l);
+
+	pwtest_neg_errno_ok(pw_data_loop_start(dl));
+
+	pw_loop_invoke(l, ctwd_add_source, 0, NULL, 0, true, &data);
+	pwtest_ptr_notnull(data.source.loop);
+
+	write_eventfd(data.source.fd);
+	read_eventfd(data.handler_running_barrier);
+
+	pwtest_neg_errno_ok(pw_data_loop_stop(dl));
+
+	/* these are the important checks */
+	pwtest_ptr_null(data.source.priv);
+	pwtest_int_eq(data.source.rmask, UINT32_C(0));
+
+	pw_loop_remove_source(l, &data.source);
+
+	pw_data_loop_destroy(dl);
+
+	close(data.source.fd);
+	close(data.handler_running_barrier);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
 PWTEST_SUITE(support)
 {
 	pwtest_add(pwtest_loop_destroy2, PWTEST_NOARG);
@@ -381,6 +457,7 @@
 	pwtest_add(pwtest_loop_recurse2, PWTEST_NOARG);
 	pwtest_add(destroy_managed_source_before_dispatch, PWTEST_NOARG);
 	pwtest_add(destroy_managed_source_before_dispatch_recurse, PWTEST_NOARG);
+	pwtest_add(cancel_thread_while_dispatching, PWTEST_NOARG);
 
 	return PWTEST_PASS;
 }

Changes of Revision 9