PipeWire

https://docs.pipewire.org
Admin
PipeWire is a low-level multimedia framework providing graph-based audio and video processing with...
Tokens:956,632
Snippets:7,981
Trust Score:9.4
Update:1 day ago
Show doc for...
Tokens:
Raw
### PipeWire Loop and SDL Setup

Source: https://docs.pipewire.org/local-v4l2_8c-example.html

Initializes a PipeWire loop and SDL window for a video4linux2 example. Retrieves Loop and LoopControl interfaces, sets up support for logging and loops, initializes SDL, creates nodes, negotiates formats, and runs the loop.

```c
if (([res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137) = [spa\_handle\_get\_interface](https://docs.pipewire.org/group__spa__handle.html#ga1e93d12bd4ee38279f65ec924108c1d6)(handle, [SPA\_TYPE\_INTERFACE\_Loop](https://docs.pipewire.org/group__spa__loop.html#ga5ea06c2ace410d56b97b466704b3ded7), &iface)) < 0) {

printf("can't get interface %d\\n", [res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137));

return [res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137);

}

data.loop = iface;

if (([res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137) = [spa\_handle\_get\_interface](https://docs.pipewire.org/group__spa__handle.html#ga1e93d12bd4ee38279f65ec924108c1d6)(handle, [SPA\_TYPE\_INTERFACE\_LoopControl](https://docs.pipewire.org/group__spa__loop.html#gacafe7661d00fa945b3c4f3471ef3e2c3), &iface)) < 0) {

printf("can't get interface %d\\n", [res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137));

return [res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137);

}

data.control = iface;

data.use\_buffer = true;

data.log = &default\_log.log;

if ((str = getenv("SPA\_DEBUG")))

data.log->level = atoi(str);

data.support\[data.n\_support++\] = [SPA\_SUPPORT\_INIT](https://docs.pipewire.org/group__spa__handle.html#ga46953719ebad900370c1ac50ac1a9fcd)([SPA\_TYPE\_INTERFACE\_Log](https://docs.pipewire.org/group__spa__log.html#gaae4067126110801d47890be91be83c5e), data.log);

data.support\[data.n\_support++\] = [SPA\_SUPPORT\_INIT](https://docs.pipewire.org/group__spa__handle.html#ga46953719ebad900370c1ac50ac1a9fcd)([SPA\_TYPE\_INTERFACE\_Loop](https://docs.pipewire.org/group__spa__loop.html#ga5ea06c2ace410d56b97b466704b3ded7), data.loop);

data.support\[data.n\_support++\] = [SPA\_SUPPORT\_INIT](https://docs.pipewire.org/group__spa__handle.html#ga46953719ebad900370c1ac50ac1a9fcd)([SPA\_TYPE\_INTERFACE\_DataLoop](https://docs.pipewire.org/group__spa__loop.html#ga5be1a481702843ffab8cfe42d3b6cfe1), data.loop);

if (SDL\_Init(SDL\_INIT\_VIDEO) < 0) {

printf("can't initialize SDL: %s\\n", SDL\_GetError());

return -1;

}

if (SDL\_CreateWindowAndRenderer

(320, 240, SDL\_WINDOW\_RESIZABLE, &data.window, &data.renderer)) {

printf("can't create window: %s\\n", SDL\_GetError());

return -1;

}

if (([res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137) = make\_nodes(&data, argv\[1\])) < 0) {

printf("can't make nodes: %d\\n", [res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137));

return -1;

}

if (([res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137) = negotiate\_formats(&data)) < 0) {

printf("can't negotiate nodes: %d\\n", [res](https://docs.pipewire.org/group__pw__core.html#gac47bc0c8feb8377c35d99b9bd66b9137));

return -1;

}

[spa\_loop\_control\_enter](https://docs.pipewire.org/group__spa__loop.html#ga1bf51a8bd1d25737efaabb4acea112f3)(data.control);

loop(&data);

[spa\_loop\_control\_leave](https://docs.pipewire.org/group__spa__loop.html#gae84e8eb30c8c4577cb8a0bea2eca8f60)(data.control);

SDL\_DestroyRenderer(data.renderer);

return 0;

}
```

--------------------------------

### PipeWire video sync example: main function with option parsing and stream setup

Source: https://docs.pipewire.org/video-play-sync_8c-example.html

This is the main function of the video-sync example. It initializes PipeWire, parses command-line options (including -S, -R, -F for sync and release features), creates a main loop with signal handlers, and creates a simple stream with video capture properties. The stream target can be specified as a positional argument.

```c
fprintf(stderr, "supported DSP formats:\n");

spa_debug_format(2, NULL, params[1]);

return n_params;

}

static void do_quit(void *userdata, int signal_number)

{

struct data *data = userdata;

pw_main_loop_quit(data->loop);

}

static void show_help(struct data *data, const char *name, bool is_error)

{

FILE *fp;

fp = is_error ? stderr : stdout;

fprintf(fp,

"%s [options]\n"

" -h, --help Show this help\n"

" --version Show version\n"

" -r, --remote Remote daemon name\n"

" -S, --sync Enable SyncTimeline\n"

" -R, --release Enable RELEASE feature\n"

" -F, --force-release RELEASE feature needs to be present\n"

"\n", name);

}

int main(int argc, char *argv[])

{

struct data data = { 0, };

const struct spa_pod *params[3];

uint8_t buffer[1024];

struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));

struct pw_properties *props;

int res, n_params;

static const struct option long_options[] = {

{ "help", no_argument, NULL, 'h' },

{ "version", no_argument, NULL, 'V' },

{ "remote", required_argument, NULL, 'r' },

{ "sync", no_argument, NULL, 'S' },

{ "release", no_argument, NULL, 'R' },

{ "force-release", no_argument, NULL, 'F' },

{ NULL, 0, NULL, 0}

};

char *opt_remote = NULL;

int c;

pw_init(&argc, &argv);

while ((c = getopt_long(argc, argv, "hVr:SRF", long_options, NULL)) != -1) {

switch (c) {

case 'h':

show_help(&data, argv[0], false);

return 0;

case 'V':

printf("%s\n"

"Compiled with libpipewire %s\n"

"Linked with libpipewire %s\n",

argv[0],

pw_get_headers_version(),

pw_get_library_version());

return 0;

case 'r':

opt_remote = optarg;

break;

case 'F':

data.force_synctimeline_release = true;

SPA_FALLTHROUGH;

case 'R':

data.with_synctimeline_release = true;

SPA_FALLTHROUGH;

case 'S':

data.with_synctimeline = true;

break;

default:

show_help(&data, argv[0], true);

return -1;

}

}

/* create a main loop */

data.loop = pw_main_loop_new(NULL);

pw_loop_add_signal(pw_main_loop_get_loop(data.loop), SIGINT, do_quit, &data);

pw_loop_add_signal(pw_main_loop_get_loop(data.loop), SIGTERM, do_quit, &data);

/* create a simple stream, the simple stream manages to core and remote

* objects for you if you don't need to deal with them

*

* If you plan to autoconnect your stream, you need to provide at least

* media, category and role properties

*

* Pass your events and a user_data pointer as the last arguments. This

* will inform you about the stream state. The most important event

* you need to listen to is the process event where you need to consume

* the data provided to you.

*/

props = pw_properties_new(PW_KEY_MEDIA_TYPE, "Video",

PW_KEY_MEDIA_CATEGORY, "Capture",

PW_KEY_MEDIA_ROLE, "Camera",

PW_KEY_REMOTE_NAME, opt_remote,

NULL),

data.path = optind < argc ? argv[optind++] : "video-src-sync";

if (data.path)

pw_properties_set(props, PW_KEY_TARGET_OBJECT, data.path);

data.stream = pw_stream_new_simple(
```

--------------------------------

### local-libcamera.c: Example using libspa-libcamera with SPA

Source: https://docs.pipewire.org/spa_2examples_2local-libcamera_8c-example.html

This is the complete source file for the example. It includes necessary headers, defines constants like WIDTH and HEIGHT, defines buffer and data structures, and starts with a function to load a SPA plugin handle. The example is intended to show how to use libspa-libcamera with only the SPA API.

```c
/* Spa */

/* SPDX-FileCopyrightText: Copyright © 2020 Collabora Ltd. */
/* @author Raghavendra Rao Sidlagatta <raghavendra.rao@collabora.com> */
/* SPDX-License-Identifier: MIT */

/*
[title]

Example using libspa-libcamera, with only \ref api_spa

[title]
*/

#include "config.h"

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include <poll.h>
#include <pthread.h>
#include <errno.h>
#include <sys/mman.h>
#include <SDL2/SDL.h>

#include <spa/support/plugin.h>
#include <spa/utils/keys.h>
#include <spa/utils/names.h>
#include <spa/utils/result.h>
#include <spa/utils/string.h>
#include <spa/support/log-impl.h>
#include <spa/support/loop.h>
#include <spa/node/node.h>
#include <spa/node/io.h>
#include <spa/node/utils.h>
#include <spa/param/param.h>
#include <spa/param/props.h>
#include <spa/param/video/format-utils.h>
#include <spa/debug/pod.h>

#define WIDTH 640
#define HEIGHT 480

static SPA_LOG_IMPL(default_log);

#define MAX_BUFFERS 8
#define LOOP_TIMEOUT_MS 100
#define USE_BUFFER false

struct buffer {
	struct spa_buffer buffer;
	struct spa_meta metas[1];
	struct spa_meta_header header;
	struct spa_data datas[1];
	struct spa_chunk chunks[1];
	SDL_Texture *texture;
};

struct data {
	const char *plugin_dir;
	struct spa_log *log;
	struct spa_system *system;
	struct spa_loop *loop;
	struct spa_loop_control *control;
	struct spa_support support[5];
	uint32_t n_support;

	struct spa_node *source;
	struct spa_hook listener;
	struct spa_io_buffers source_output[1];

	SDL_Renderer *renderer;
	SDL_Window *window;
	SDL_Texture *texture;

	bool use_buffer;
	bool running;
	pthread_t thread;

	struct spa_buffer *bp[MAX_BUFFERS];
	struct buffer buffers[MAX_BUFFERS];
	unsigned int n_buffers;
};

static int load_handle(struct data *data, struct spa_handle **handle, const char *lib, const char *name,
		const struct spa_dict *params)
{
	int res;
	void *hnd;
	spa_handle_factory_enum_func_t enum_func;
	uint32_t i;
	char *path = NULL;

	if ((path = spa_aprintf("%s/%s", data->plugin_dir, lib)) == NULL) {
		return -ENOMEM;
	}

	if ((hnd = dlopen(path, RTLD_NOW)) == NULL) {
		printf("can't load %s: %s\n", path, dlerror());
		free(path);
		return -errno;
	}
	free(path);

	if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
		printf("can't find enum function\n");
		return -errno;
	}

	for (i = 0;;) {
		const struct spa_handle_factory *factory;

```

--------------------------------

### video-play main function: stream setup, connection, and main loop

Source: https://docs.pipewire.org/video-play_8c-example.html

This is the main function of the video-play example. It sets up a PipeWire stream with a media role 'Camera', optionally sets a target object from command-line arguments, initializes SDL for video output, builds format parameters and a tag parameter, connects the stream with autoconnect, inactive, and map-buffers flags, runs the main loop, and cleans up resources.

```c
PW_KEY_MEDIA_ROLE, "Camera",

NULL),

data.path = argc > 1 ? argv[1] : NULL;

if (data.path)

pw_properties_set(props, PW_KEY_TARGET_OBJECT, data.path);

data.stream = pw_stream_new_simple(

pw_main_loop_get_loop(data.loop),

"video-play",

props,

&stream_events,

&data);

if (SDL_Init(SDL_INIT_VIDEO) < 0) {

fprintf(stderr, "can't initialize SDL: %s\n", SDL_GetError());

return -1;

}

if (SDL_CreateWindowAndRenderer

(WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) {

fprintf(stderr, "can't create window: %s\n", SDL_GetError());

return -1;

}

/* build the extra parameters to connect with. To connect, we can provide

* a list of supported formats. We use a builder that writes the param

* object to the stack. */

n_params = build_format(&data, &b, params);

{

struct spa_pod_frame f;

struct spa_dict_item items[1];

/* send a tag, input tags travel upstream */

spa_tag_build_start(&b, &f, SPA_PARAM_Tag, SPA_DIRECTION_INPUT);

items[0] = SPA_DICT_ITEM_INIT("my-tag-other-key", "my-special-other-tag-value");

spa_tag_build_add_dict(&b, &SPA_DICT_INIT(items, 1));

params[n_params++] = spa_tag_build_end(&b, &f);

}

/* now connect the stream, we need a direction (input/output),

* an optional target node to connect to, some flags and parameters

*/

if ((res = pw_stream_connect(data.stream,

PW_DIRECTION_INPUT,

PW_ID_ANY,

PW_STREAM_FLAG_AUTOCONNECT | /* try to automatically connect this stream */

PW_STREAM_FLAG_INACTIVE | /* we will activate ourselves */

PW_STREAM_FLAG_MAP_BUFFERS, /* mmap the buffer data for us */

params, n_params)) /* extra parameters, see above */ < 0) {

fprintf(stderr, "can't connect: %s\n", spa_strerror(res));

return -1;

}

/* do things until we quit the mainloop */

pw_main_loop_run(data.loop);

pw_stream_destroy(data.stream);

pw_main_loop_destroy(data.loop);

SDL_DestroyTexture(data.texture);

if (data.cursor)

SDL_DestroyTexture(data.cursor);

SDL_DestroyRenderer(data.renderer);

SDL_DestroyWindow(data.window);

pw_deinit();

return 0;
}
```

--------------------------------

### Example configuration with default module

Source: https://docs.pipewire.org/1.6/page_module_protocol_native.html

Example context.modules configuration that loads the protocol-native module with default arguments.

```conf
context.modules = [

{ name = libpipewire-module-protocol-native }

]
```

--------------------------------

### Example configuration for context.modules

Source: https://docs.pipewire.org/1.6/page_module_access.html

Example configuration showing how to load the access module with socket-specific permissions. Uses pipewire-0 for usual applications and pipewire-0-manager for session manager applications.

```conf
context.modules = [

{ name = libpipewire-module-access

args = {

# Use separate socket for session manager applications,

# and pipewire-0 for usual applications.

access.socket = {

pipewire-0 = "default",

pipewire-0-manager = "unrestricted",

}

}

}

]
```

--------------------------------

### pulse.cmd example for loading modules at startup

Source: https://docs.pipewire.org/1.6/page_man_pipewire-pulse_conf_5.html

Example configuration for the pulse.cmd section in pipewire-pulse.conf. It loads three modules at startup: module-always-sink, module-switch-on-connect, and module-gsettings (with nofail flag). The example is intended for ~/.config/pipewire/pipewire-pulse.conf.d/custom.conf.

```conf
# ~/.config/pipewire/pipewire-pulse.conf.d/custom.conf

pulse.cmd = [
    { cmd = "load-module" args = "module-always-sink" flags = [ ] }
    { cmd = "load-module" args = "module-switch-on-connect" }
    { cmd = "load-module" args = "module-gsettings" flags = [ "nofail" ] }
]
```

--------------------------------

### Example configuration for libpipewire-module-snapcast-discover

Source: https://docs.pipewire.org/1.6/page_module_snapcast_discover.html

Configuration file example for the Snapcast Discover module. It sets up stream.rules with a match on snapcast.ip and a create-stream action with commented-out optional properties. The file is intended to be placed at ~/.config/pipewire/pipewire.conf.d/my-snapcast-discover.conf.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-snapcast-discover.conf

context.modules = [

{ name = libpipewire-module-snapcast-discover
args = {
stream.rules = [
{ matches = [
{ snapcast.ip = "~.*"
#snapcast.port = 1000
#snapcast.ifindex = 1
#snapcast.ifname = eth0
#snapcast.name = ""
#snapcast.hostname = ""
#snapcast.domain = ""
}
]
actions = {
create-stream = {
#audio.rate = 44100
#audio.format = S16LE # S16LE, S24_32LE, S32LE
#audio.channels = 2
#audio.position = [ FL FR ]
#
# The stream name as is appears on the snapcast
# server:
#snapcast.stream-name = "PipeWire"
#
# The name of the sink on the sender:
#node.name = "Snapcast Sink"
#
#capture = true
#server.address = [ "tcp:4711" ]
#capture.props = {
#target.object = ""
#node.latency = 2048/48000
#media.class = "Audio/Sink"
#}
}
}
}
]
}
}

]

```

--------------------------------

### Example configuration for libpipewire-module-raop-discover

Source: https://docs.pipewire.org/1.6/page_module_raop_discover.html

Configuration example for the RAOP Discover module. It sets up stream.rules to match RAOP streams and create sinks. The example shows commented-out options for discovery, latency, and various stream properties. The file is typically placed at ~/.config/pipewire/pipewire.conf.d/my-raop-discover.conf.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-raop-discover.conf

context.modules = [

{ name = libpipewire-module-raop-discover

args = {

#raop.discover-local = false;

#raop.latency.ms = 1000

stream.rules = [

{ matches = [

{ raop.ip = "~.*"

#raop.port = 1000

#raop.name = ""

#raop.hostname = ""

#raop.domain = ""

#raop.device = ""

#raop.transport = "udp" | "tcp"

#raop.encryption.type = "none" | "RSA" | "auth_setup" | "fp_sap25"

#raop.audio.codec = "PCM" | "ALAC" | "AAC" | "AAC-ELD"

#audio.channels = 2

#audio.format = "S16" | "S24" | "S32"

#audio.rate = 44100

#device.model = ""

}

]

actions = {

create-stream = {

#raop.password = ""

stream.props = {

#target.object = ""

#media.class = "Audio/Sink"

}

}

}

}

]

}

}

]
```

--------------------------------

### PipeWire Audio Capture Main Loop and Stream Setup

Source: https://docs.pipewire.org/audio-capture_8c-example.html

This snippet shows the main function for an audio capture example. It initializes PipeWire, creates a main loop, sets up signal handlers, creates a stream with properties, and connects it. The stream is configured to capture audio with F32 format and autoconnect.

```c
static void do_quit(void *userdata, int signal_number)
{
	struct data *data = userdata;
	pw_main_loop_quit(data->loop);
}

int main(int argc, char *argv[])
{
	struct data data = { 0, };
	const struct spa_pod *params[1];
	uint32_t n_params = 0;
	uint8_t buffer[1024];
	struct pw_properties *props;
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));

	pw_init(&argc, &argv);

	/* make a main loop. If you already have another main loop, you can add
	 * the fd of this pipewire mainloop to it. */
	data.loop = pw_main_loop_new(NULL);
	pw_loop_add_signal(pw_main_loop_get_loop(data.loop), SIGINT, do_quit, &data);
	pw_loop_add_signal(pw_main_loop_get_loop(data.loop), SIGTERM, do_quit, &data);

	/* Create a simple stream, the simple stream manages the core and remote
	 * objects for you if you don't need to deal with them.
	 *
	 * If you plan to autoconnect your stream, you need to provide at least
	 * media, category and role properties.
	 *
	 * Pass your events and a user_data pointer as the last arguments. This
	 * will inform you about the stream state. The most important event
	 * you need to listen to is the process event where you need to produce
	 * the data.
	 */
	props = pw_properties_new(PW_KEY_MEDIA_TYPE, "Audio",
			PW_KEY_MEDIA_CATEGORY, "Capture",
			PW_KEY_MEDIA_ROLE, "Music",
			NULL);

	if (argc > 1)
		/* Set stream target if given on command line */
		pw_properties_set(props, PW_KEY_TARGET_OBJECT, argv[1]);

	/* uncomment if you want to capture from the sink monitor ports */
	/* pw_properties_set(props, PW_KEY_STREAM_CAPTURE_SINK, "true"); */

	data.stream = pw_stream_new_simple(
			pw_main_loop_get_loop(data.loop),
			"audio-capture",
			props,
			&stream_events,
			&data);

	/* Make one parameter with the supported formats. The SPA_PARAM_EnumFormat
	 * id means that this is a format enumeration (of 1 value).
	 * We leave the channels and rate empty to accept the native graph
	 * rate and channels. */
	params[n_params++] = spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat,
			&SPA_AUDIO_INFO_RAW_INIT(
				.format = SPA_AUDIO_FORMAT_F32));

	/* Now connect this stream. We ask that our process function is
	 * called in a realtime thread. */
	pw_stream_connect(data.stream,
			PW_DIRECTION_INPUT,
			PW_ID_ANY,
			PW_STREAM_FLAG_AUTOCONNECT |
			PW_STREAM_FLAG_MAP_BUFFERS |
			0,
			params, n_params);

	/* ... */
}
```

--------------------------------

### PipeWire parametric equalizer module configuration example

Source: https://docs.pipewire.org/1.6/page_module_parametric_equalizer.html

Example configuration for loading the libpipewire-module-parametric-equalizer module in a PipeWire configuration file. The example shows the module name, arguments, and commented-out options for remote.name, equalizer.filepath, equalizer.description, audio.channels, audio.position, capture.props, and playback.props.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-parametric-equalizer.conf

context.modules = [

{ name = libpipewire-module-parametric-equalizer

args = {

#remote.name = "pipewire-0"

#equalizer.filepath = "/a/b/EQ.txt"

#equalizer.description = "Parametric EQ Sink"

#audio.channels = 2

#audio.position = [FL, FR]

#capture.props = {

# node.name = "Parametric EQ input"

#}

#playback.props = {

# node.name = "Parametric EQ output"

#}

}

}

]
```

--------------------------------

### Example configuration for libpipewire-module-example-sink

Source: https://docs.pipewire.org/1.6/page_module_example_sink.html

Configuration snippet for ~/.config/pipewire/pipewire.conf.d/my-example-sink.conf that loads the example sink module with node.name, node.description, and stream.props settings.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-example-sink.conf

context.modules = [

{ name = libpipewire-module-example-sink
args = {
node.name = "example_sink"
node.description = "My Example Sink"
stream.props = {
audio.position = [ FL FR ]
}
}
}

]
```

--------------------------------

### Example configuration with custom sockets

Source: https://docs.pipewire.org/1.6/page_module_protocol_native.html

Example context.modules configuration that loads the protocol-native module with custom socket definitions, including a socket with additional properties.

```conf
context.modules = [

{ name = libpipewire-module-protocol-native,

args = {

sockets = [

{ name = "pipewire-0" }

{ name = "pipewire-0-manager" }

{ name = "pipewire-1"

props = { my.connection = "the other one" }

}

]

}

}
```

--------------------------------

### Example configuration for libpipewire-module-example-source

Source: https://docs.pipewire.org/1.6/page_module_example_source.html

Configuration snippet for ~/.config/pipewire/pipewire.conf.d/my-example-source.conf. It loads the example source module with a unique node name, a human-readable description, and stream properties specifying the audio channel layout as FL FR.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-example-source.conf

context.modules = [

{ name = libpipewire-module-example-source

args = {

node.name = "example_source"

node.description = "My Example Source"

stream.props = {

audio.position = [ FL FR ]
}

}

}

]
```

--------------------------------

### Example configuration for libpipewire-module-rtp-session

Source: https://docs.pipewire.org/1.6/page_module_rtp_session.html

Configuration file example for enabling the RTP session module. Place this in ~/.config/pipewire/pipewire.conf.d/my-rtp-session.conf. The example shows the module with commented-out options and a stream.props section setting node.name to "rtp-sink".

```conf
# ~/.config/pipewire/pipewire.conf.d/my-rtp-session.conf

context.modules = [

{ name = libpipewire-module-rtp-session
args = {
#local.ifname = "eth0"
#control.ip = "0.0.0.0"
#control.port = 0
#net.mtu = 1280
#net.ttl = 1
#net.loop = false
#sess.discover-local = false
#sess.min-ptime = 2
#sess.max-ptime = 20
#sess.name = "PipeWire RTP stream"
#sess.media = "audio"
stream.props = {
node.name = "rtp-sink"
#audio.format = "S16BE"
#audio.rate = 48000
#audio.channels = 2
#audio.position = [ FL FR ]
}
}
}

]
```

--------------------------------

### context.exec example: run pactl command

Source: https://docs.pipewire.org/1.6/page_man_pipewire_conf_5.html

Example that executes the pactl command with the argument 'load-module module-always-sink' during PipeWire initialization.

```conf
# ~/.config/pipewire/pipewire.conf.d/custom.conf

context.exec = [

{ path = "pactl" args = "load-module module-always-sink" }

]
```

--------------------------------

### Example configuration for libpipewire-module-jackdbus-detect

Source: https://docs.pipewire.org/1.6/page_module_jackdbus_detect.html

Example configuration for ~/.config/pipewire/pipewire.conf.d/my-jack-dbus-detect.conf. It loads the module with commented options for jack.server, tunnel.mode, audio.channels, audio.position, and includes source.props and sink.props sections for extra properties.

```conf
context.modules = [

{ name = libpipewire-module-jackdbus-detect

args {

#jack.server = null

#tunnel.mode = duplex

#audio.channels = 2

#audio.position = [ FL FR ]

source.props = {

# extra sink properties

}

sink.props = {

# extra sink properties

}

}

}

]
```

--------------------------------

### Example configuration for libpipewire-module-x11-bell

Source: https://docs.pipewire.org/1.6/page_module_x11_bell.html

Configuration snippet showing how to load the x11-bell module with optional settings. The sample.name is set to 'bell-window-system', while sink.name, x11.display, and x11.xauthority are commented out as examples.

```plaintext
context.modules = [

{ name = libpipewire-module-x11-bell }

args = {

#sink.name = @DEFAULT_SINK@

sample.name = "bell-window-system"

#x11.display = ":1"

#x11.xauthority = "test"

]
```

--------------------------------

### Example configuration of a duplex sink/source

Source: https://docs.pipewire.org/1.6/page_module_ffado_driver.html

Configuration example for the ffado-driver module, typically placed in ~/.config/pipewire/pipewire.conf.d/my-ffado-driver.conf. It shows how to load the module with default or commented-out options, and includes source.props and sink.props for extra properties.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-ffado-driver.conf

context.modules = [

{ name = libpipewire-module-ffado-driver

args = {

#driver.mode = duplex

#ffado.devices = [ "hw:0" ]

#ffado.period-size = 1024

#ffado.period-num = 3

#ffado.sample-rate = 48000

#ffado.slave-mode = false

#ffado.snoop-mode = false

#ffado.verbose = 0

#ffado.rtprio = 65

#ffado.realtime = true

#latency.internal.input = 0

#latency.internal.output = 0

#audio.position = [ FL FR ]

source.props = {

# extra sink properties

}

sink.props = {

# extra sink properties

}

}

}

]
```

--------------------------------

### Example stream.properties configuration for pipewire-pulse.conf

Source: https://docs.pipewire.org/1.6/page_man_pipewire-pulse_conf_5.html

Example configuration file for ~/.config/pipewire/pipewire-pulse.conf.d/custom.conf. All properties are commented out; uncomment to set values. Includes node.latency, node.autoconnect, resample.disable, resample.quality, monitor.channel-volumes, channelmix.*, dither.*, and debug.wav-path.

```conf
# ~/.config/pipewire/pipewire-pulse.conf.d/custom.conf

stream.properties = {

#node.latency = 1024/48000

#node.autoconnect = true

#resample.disable = false

#resample.quality = 4

#monitor.channel-volumes = false

#channelmix.disable = false

#channelmix.min-volume = 0.0

#channelmix.max-volume = 10.0

#channelmix.normalize = false

#channelmix.mix-lfe = true

#channelmix.upmix = true

#channelmix.upmix-method = psd # none, simple

#channelmix.lfe-cutoff = 150.0

#channelmix.fc-cutoff = 12000.0

#channelmix.rear-delay = 12.0

#channelmix.stereo-widen = 0.0

#channelmix.hilbert-taps = 0

#dither.noise = 0

#dither.method = none # rectangular, triangular, triangular-hf, wannamaker3, shaped5

#debug.wav-path = ""

}
```

--------------------------------

### spa-inspect example: Display plugin information

Source: https://docs.pipewire.org/1.6/page_man_spa-inspect_1.html

Run spa-inspect with a SPA plugin file path to display information about the plugin and list its factories. The example uses the bluez5 SBC codec plugin.

```bash
**spa-inspect** /usr/lib64/spa-0.2/bluez5/libspa-codec-bluez5-sbc.so
```

--------------------------------

### Example configuration of a duplex sink/source

Source: https://docs.pipewire.org/1.6/page_module_jack_tunnel.html

Configuration file example for the jack-tunnel module, typically placed at ~/.config/pipewire/pipewire.conf.d/my-jack-tunnel.conf. It shows the context.modules array with the module name and args, including commented-out options for customization.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-jack-tunnel.conf

context.modules = [

{ name = libpipewire-module-jack-tunnel
args = {
#jack.library = libjack.so.0
#jack.server = null
#jack.client-name = PipeWire
#jack.connect = true
#jack.connect-audio = [ playback_1 playback_2 ]
#jack.connect-midi = [ midi_playback_1 ]
#tunnel.mode = duplex
#midi.ports = 0
#audio.channels = 2
#audio.position = [ FL FR ]
source.props = {
# extra sink properties
}
sink.props = {
# extra sink properties
}
}
}

]
```

--------------------------------

### PipeWire video capture stream setup and main loop (C)

Source: https://docs.pipewire.org/video-play-reneg_8c-example.html

Initializes PipeWire, creates a main loop, sets up a simple stream with media properties, initializes SDL, connects the stream as input with autoconnect and buffer mapping, adds a timer, runs the loop, and cleans up.

```c
int res, n_params;

pw_init(&argc, &argv);

/* create a main loop */

data.loop = pw_main_loop_new(NULL);

pw_loop_add_signal(pw_main_loop_get_loop(data.loop), SIGINT, do_quit, &data);

pw_loop_add_signal(pw_main_loop_get_loop(data.loop), SIGTERM, do_quit, &data);

/* create a simple stream, the simple stream manages to core and remote
 * objects for you if you don't need to deal with them
 *
 * If you plan to autoconnect your stream, you need to provide at least
 * media, category and role properties
 *
 * Pass your events and a user_data pointer as the last arguments. This
 * will inform you about the stream state. The most important event
 * you need to listen to is the process event where you need to consume
 * the data provided to you.
 */
props = pw_properties_new(PW_KEY_MEDIA_TYPE, "Video",
        PW_KEY_MEDIA_CATEGORY, "Capture",
        PW_KEY_MEDIA_ROLE, "Camera",
        NULL),
data.path = argc > 1 ? argv[1] : NULL;

if (data.path)
    /* Set stream target if given on command line */
    pw_properties_set(props, PW_KEY_TARGET_OBJECT, data.path);

data.stream = pw_stream_new_simple(
        pw_main_loop_get_loop(data.loop),
        "video-play-reneg",
        props,
        &stream_events,
        &data);

if (SDL_Init(SDL_INIT_VIDEO) < 0) {
    fprintf(stderr, "can't initialize SDL: %s\n", SDL_GetError());
    return -1;
}

if (SDL_CreateWindowAndRenderer
        (WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) {
    fprintf(stderr, "can't create window: %s\n", SDL_GetError());
    return -1;
}

/* build the extra parameters to connect with. To connect, we can provide
 * a list of supported formats. We use a builder that writes the param
 * object to the stack. */
n_params = build_format(&data, &b, params);

/* now connect the stream, we need a direction (input/output),
 * an optional target node to connect to, some flags and parameters
 */
if ((res = pw_stream_connect(data.stream,
        PW_DIRECTION_INPUT,
        PW_ID_ANY,
        PW_STREAM_FLAG_AUTOCONNECT | /* try to automatically connect this stream */
        PW_STREAM_FLAG_MAP_BUFFERS, /* mmap the buffer data for us */
        params, n_params)) /* extra parameters, see above */ < 0) {
    fprintf(stderr, "can't connect: %s\n", spa_strerror(res));
    return -1;
}

data.timer = pw_loop_add_timer(pw_main_loop_get_loop(data.loop), on_timeout, &data);

/* do things until we quit the mainloop */
pw_main_loop_run(data.loop);

pw_stream_destroy(data.stream);
pw_main_loop_destroy(data.loop);

SDL_DestroyTexture(data.texture);
```

--------------------------------

### PipeWire SPA videotestsrc with SDL rendering

Source: https://docs.pipewire.org/spa_2examples_2local-videotestsrc_8c-example.html

This C code demonstrates a complete PipeWire SPA example that uses a videotestsrc node and SDL for rendering. It shows how to load the SPA support library, get the System interface, create a source node, allocate buffers, start and pause the node, and run an SDL event loop. The code includes error handling and uses the SPA_LOOP_TIMEOUT_MS constant for the loop timeout.

```c
if ((res = spa_node_port_use_buffers(data->source,
					SPA_DIRECTION_OUTPUT, 0,
					SPA_NODE_BUFFERS_FLAG_ALLOC,
					data->bp, data->n_buffers)) < 0) {
			printf("can't allocate buffers: %s\n", spa_strerror(res));
			return -1;
		}
	} else {
		unsigned int n_buffers;

		data->texture = SDL_CreateTexture(data->renderer,
				SDL_PIXELFORMAT_RGB24,
				SDL_TEXTUREACCESS_STREAMING, WIDTH, HEIGHT);
		if (!data->texture) {
			printf("can't create texture: %s\n", SDL_GetError());
			return -1;
		}

		n_buffers = MAX_BUFFERS;
		if ((res = spa_node_port_use_buffers(data->source,
					SPA_DIRECTION_OUTPUT, 0,
					SPA_NODE_BUFFERS_FLAG_ALLOC,
					data->bp, n_buffers)) < 0) {
			printf("can't allocate buffers: %s\n", spa_strerror(res));
			return -1;
		}
		data->n_buffers = n_buffers;
	}
	return 0;
}

static void loop(struct data *data)
{
	int res;
	struct spa_command cmd;
	SDL_Event event;

	printf("starting...\n\n");

	cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
	if ((res = spa_node_send_command(data->source, &cmd)) < 0)
		printf("got error %d\n", res);

	data->running = true;
	while (data->running) {
		// must be called from the thread that created the renderer
		while (SDL_PollEvent(&event)) {
			switch (event.type) {
			case SDL_QUIT:
				data->running = false;
				break;
			}
		}
		// small timeout to make sure we don't starve the SDL loop
		spa_loop_control_iterate(data->control, LOOP_TIMEOUT_MS);
	}

	printf("pausing...\n\n");

	cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
	if ((res = spa_node_send_command(data->source, &cmd)) < 0)
		printf("got error %d\n", res);
}

int main(int argc, char *argv[])
{
	struct data data = { 0 };
	int res;
	const char *str;
	struct spa_handle *handle = NULL;
	void *iface;
	uint32_t pattern = 0;

	if ((str = getenv("SPA_PLUGIN_DIR")) == NULL)
		str = PLUGINDIR;
	data.plugin_dir = str;

	if ((res = load_handle(&data, &handle,
				"support/libspa-support.so",
				SPA_NAME_SUPPORT_SYSTEM)) < 0)
		return res;

	if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_System, &iface)) < 0) {
		printf("can't get System interface %d\n", res);
		return res;
	}
	data.system = iface;
```

--------------------------------

### Start BlueZ SPA device monitor

Source: https://docs.pipewire.org/bluez-session_8c-example.html

Loads the BlueZ SPA handle, gets the Device interface, and adds a listener for device events. Returns 0 on success or a negative error code.

```c
static int start_monitor(struct impl *impl)
{
	struct spa_handle *handle;
	int res;
	void *iface;

	handle = pw_context_load_spa_handle(impl->context, SPA_NAME_API_BLUEZ5_ENUM_DBUS, &impl->props->dict);
	if (handle == NULL) {
		res = -errno;
		goto out;
	}

	if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Device, &iface)) < 0) {
		pw_log_error("can't get MONITOR interface: %d", res);
		goto out_unload;
	}

	impl->handle = handle;
	impl->device = iface;
	spa_device_add_listener(impl->device, &impl->listener, &dbus_device_events, impl);

	return 0;

out_unload:
	pw_unload_spa_handle(handle);
out:
	return res;
}
```

--------------------------------

### node.rules example for jack_simple_client

Source: https://docs.pipewire.org/1.6/page_man_pipewire_conf_5.html

Configures node.rules to override properties on nodes. The match rule targets the client.name "jack_simple_client" and sets node.force-quantum to 512. All keys must match; ! negates and ~ starts regex.

```conf
# ~/.config/pipewire/pipewire.conf.d/custom.conf

node.rules = [
{
matches = [
{
# all keys must match the value. ! negates. ~ starts regex.
client.name = "jack_simple_client"
}
]
actions = {
update-props = {
node.force-quantum = 512
}
}
}
]
```

--------------------------------

### PipeWire video-play-sync: stream setup and SDL initialization

Source: https://docs.pipewire.org/video-play-sync_8c-example.html

Initializes SDL, creates a window and renderer, and sets up the PipeWire stream with the main loop. Uses SDL_INIT_VIDEO and SDL_CreateWindowAndRenderer with WIDTH and HEIGHT constants.

```c
pw_main_loop_get_loop(data.loop),

"video-play",

props,

&stream_events,

&data);

if (SDL_Init(SDL_INIT_VIDEO) < 0) {

fprintf(stderr, "can't initialize SDL: %s\n", SDL_GetError());

return -1;

}

if (SDL_CreateWindowAndRenderer

(WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) {

fprintf(stderr, "can't create window: %s\n", SDL_GetError());

return -1;

}
```

--------------------------------

### Example configuration for libpipewire-module-zeroconf-discover

Source: https://docs.pipewire.org/1.6/page_module_zeroconf_discover.html

Configuration file example for enabling the zeroconf-discover module. Place this in ~/.config/pipewire/pipewire.conf.d/my-zeroconf-discover.conf. The module automatically creates sinks and sources to stream audio to/from remote PulseAudio servers and also works with module-protocol-pulse.

```conf
# ~/.config/pipewire/pipewire.conf.d/my-zeroconf-discover.conf

context.modules = [

{ name = libpipewire-module-zeroconf-discover
args = { }
}

]
```

--------------------------------

### PipeWire core error handler and main setup

Source: https://docs.pipewire.org/bluez-session_8c-example.html

This snippet shows a complete PipeWire application setup: it initializes PipeWire, creates a main loop and context, connects to the PipeWire instance, adds a core event listener with an error handler that quits the loop on EPIPE, starts a monitor, and runs the main loop. The error handler logs errors using pw_log_error and quits the loop when the core disconnects with -EPIPE.

```c
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_main_loop_quit(impl->loop);

}

static const struct pw_core_events core_events = {

PW_VERSION_CORE_EVENTS,

.error = on_core_error,

};

int main(int argc, char *argv[])

{

struct impl impl = { 0, };

int res;

pw_init(&argc, &argv);

impl.loop = pw_main_loop_new(NULL);

impl.context = pw_context_new(pw_main_loop_get_loop(impl.loop), NULL, 0);

spa_list_init(&impl.device_list);

impl.core = pw_context_connect(impl.context, NULL, 0);

if (impl.core == NULL) {

pw_log_error(NAME" %p: can't connect %m", &impl);

return -1;

}

if ((impl.props = pw_properties_new(NULL, NULL)) == NULL) {

return -1;

}

pw_core_add_listener(impl.core,

&impl.core_listener,

&core_events, &impl);

if ((res = start_monitor(&impl)) < 0) {

pw_log_error(NAME" %p: error starting monitor: %s", &impl, spa_strerror(res));

return -1;

}

pw_main_loop_run(impl.loop);

pw_context_destroy(impl.context);

pw_main_loop_destroy(impl.loop);

return 0;

}
```

--------------------------------

### Initialize SPA parameters and connect to PipeWire core

Source: https://docs.pipewire.org/export-source_8c-example.html

Sets up a data structure with SPA parameter info entries for EnumFormat, Meta, IO, Format, and Buffers, then connects to a PipeWire instance, adds a core listener, runs the main loop, and destroys resources. The example assumes a previously created context and main loop.

```c
data.params[0] = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
data.params[1] = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
data.params[2] = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
data.params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
data.params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
data.info.params = data.params;
data.info.n_params = 5;
spa_list_init(&data.empty);
spa_hook_list_init(&data.hooks);
if ((data.core = pw_context_connect(data.context, NULL, 0)) == NULL) {
    printf("can't connect: %m\n");
    return -1;
}
pw_core_add_listener(data.core, &data.core_listener, &core_events, &data);
make_node(&data);
pw_main_loop_run(data.loop);
pw_context_destroy(data.context);
pw_main_loop_destroy(data.loop);
return 0;
}
```
Tokens:
Raw