Adding upstream version 0.3.65.upstream/0.3.65upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

19 files changed, 13379 insertions, 0 deletions

diff --git a/src/tools/dsffile.c b/src/tools/dsffile.c
new file mode 100644
index 0000000..9c6ce0c
--- /dev/null
+++ b/src/tools/dsffile.c
@@ -0,0 +1,266 @@
+/* PipeWire
+ *
+ * Copyright © 2021 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 <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <math.h>
+
+#include <spa/utils/string.h>
+
+#include "dsffile.h"
+
+struct dsf_file {
+	uint8_t *data;
+	size_t size;
+
+	int mode;
+	int fd;
+
+	struct dsf_file_info info;
+
+	uint8_t *p;
+	size_t offset;
+};
+
+static inline uint32_t parse_le32(const uint8_t *in)
+{
+	return in[0] | (in[1] << 8) | (in[2] << 16) | (in[3] << 24);
+}
+
+static inline uint64_t parse_le64(const uint8_t *in)
+{
+	uint64_t res = in[0];
+	res |= ((uint64_t)in[1]) << 8;
+	res |= ((uint64_t)in[2]) << 16;
+	res |= ((uint64_t)in[3]) << 24;
+	res |= ((uint64_t)in[4]) << 32;
+	res |= ((uint64_t)in[5]) << 40;
+	res |= ((uint64_t)in[6]) << 48;
+	res |= ((uint64_t)in[7]) << 56;
+	return res;
+}
+
+static inline int f_avail(struct dsf_file *f)
+{
+	if (f->p < f->data + f->size)
+		return f->size + f->data - f->p;
+	return 0;
+}
+
+static int read_DSD(struct dsf_file *f)
+{
+	uint64_t size;
+
+	if (f_avail(f) < 28 ||
+	    memcmp(f->p, "DSD ", 4) != 0)
+		return -EINVAL;
+
+	size = parse_le64(f->p + 4);	/* size of this chunk */
+	parse_le64(f->p + 12);		/* total size */
+	parse_le64(f->p + 20);		/* metadata */
+	f->p += size;
+	return 0;
+}
+
+static int read_fmt(struct dsf_file *f)
+{
+	uint64_t size;
+
+	if (f_avail(f) < 52 ||
+	    memcmp(f->p, "fmt ", 4) != 0)
+		return -EINVAL;
+
+	size = parse_le64(f->p + 4);	/* size of this chunk */
+	if (parse_le32(f->p + 12) != 1)	/* version */
+		return -EINVAL;
+	if (parse_le32(f->p + 16) != 0)	/* format id */
+		return -EINVAL;
+
+	f->info.channel_type = parse_le32(f->p + 20);
+	f->info.channels = parse_le32(f->p + 24);
+	f->info.rate = parse_le32(f->p + 28);
+	f->info.lsb = parse_le32(f->p + 32) == 1;
+	f->info.samples = parse_le64(f->p + 36);
+	f->info.blocksize = parse_le32(f->p + 44);
+	f->p += size;
+	return 0;
+}
+
+static int read_data(struct dsf_file *f)
+{
+	uint64_t size;
+
+	if (f_avail(f) < 12 ||
+	    memcmp(f->p, "data", 4) != 0)
+		return -EINVAL;
+
+	size = parse_le64(f->p + 4);	/* size of this chunk */
+	f->info.length = size - 12;
+	f->p += 12;
+	return 0;
+}
+
+static int open_read(struct dsf_file *f, const char *filename, struct dsf_file_info *info)
+{
+	int res;
+	struct stat st;
+
+	if ((f->fd = open(filename, O_RDONLY)) < 0) {
+		res = -errno;
+		goto exit;
+	}
+	if (fstat(f->fd, &st) < 0) {
+		res = -errno;
+		goto exit_close;
+	}
+	f->size = st.st_size;
+
+	f->data = mmap(NULL, f->size, PROT_READ, MAP_SHARED, f->fd, 0);
+	if (f->data == MAP_FAILED) {
+		res = -errno;
+		goto exit_close;
+	}
+
+	f->p = f->data;
+
+	if ((res = read_DSD(f)) < 0)
+		goto exit_unmap;
+	if ((res = read_fmt(f)) < 0)
+		goto exit_unmap;
+	if ((res = read_data(f)) < 0)
+		goto exit_unmap;
+
+	f->mode = 1;
+	*info = f->info;
+	return 0;
+
+exit_unmap:
+	munmap(f->data, f->size);
+exit_close:
+	close(f->fd);
+exit:
+	return res;
+}
+
+struct dsf_file *
+dsf_file_open(const char *filename, const char *mode, struct dsf_file_info *info)
+{
+        int res;
+        struct dsf_file *f;
+
+        f = calloc(1, sizeof(struct dsf_file));
+        if (f == NULL)
+                return NULL;
+
+        if (spa_streq(mode, "r")) {
+                if ((res = open_read(f, filename, info)) < 0)
+                        goto exit_free;
+        } else {
+                res = -EINVAL;
+                goto exit_free;
+        }
+        return f;
+
+exit_free:
+        free(f);
+        errno = -res;
+        return NULL;
+}
+
+static const uint8_t bitrev[256] = {
+	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
+};
+
+ssize_t
+dsf_file_read(struct dsf_file *f, void *data, size_t samples, const struct dsf_layout *layout)
+{
+	uint8_t *d = data;
+	int step = SPA_ABS(layout->interleave);
+	bool rev = layout->lsb != f->info.lsb;
+	size_t total, block, offset, pos, scale;
+
+	block = f->offset / f->info.blocksize;
+	offset = block * f->info.blocksize * f->info.channels;
+	pos = f->offset % f->info.blocksize;
+	scale = SPA_CLAMP(f->info.rate / (44100u * 64u), 1u, 4u);
+
+	samples *= step;
+	samples *= scale;
+
+	for (total = 0; total < samples && offset + pos < f->info.length; total++) {
+		const uint8_t *s = f->p + offset + pos;
+		uint32_t i;
+
+		for (i = 0; i < layout->channels; i++) {
+			const uint8_t *c = &s[f->info.blocksize * i];
+			int j;
+
+			if (layout->interleave > 0) {
+				for (j = 0; j < step; j++)
+					*d++ = rev ? bitrev[c[j]] : c[j];
+			} else {
+				for (j = step-1; j >= 0; j--)
+					*d++ = rev ? bitrev[c[j]] : c[j];
+			}
+		}
+		pos += step;
+		if (pos == f->info.blocksize) {
+			pos = 0;
+			offset += f->info.blocksize * f->info.channels;
+		}
+	}
+	f->offset += total * step;
+
+	return total;
+}
+
+int dsf_file_close(struct dsf_file *f)
+{
+	if (f->mode == 1) {
+		munmap(f->data, f->size);
+	} else
+		return -EINVAL;
+
+	close(f->fd);
+	free(f);
+	return 0;
+}
diff --git a/src/tools/dsffile.h b/src/tools/dsffile.h
new file mode 100644
index 0000000..616dbb1
--- /dev/null
+++ b/src/tools/dsffile.h
@@ -0,0 +1,52 @@
+/* PipeWire
+ *
+ * Copyright © 2021 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 <stdio.h>
+
+#include <spa/utils/defs.h>
+
+struct dsf_file;
+
+struct dsf_file_info {
+	uint32_t channel_type;
+	uint32_t channels;
+	uint32_t rate;
+	bool lsb;
+	uint64_t samples;
+	uint64_t length;
+	uint32_t blocksize;
+};
+
+struct dsf_layout {
+	int32_t interleave;
+	uint32_t channels;
+	bool lsb;
+};
+
+struct dsf_file * dsf_file_open(const char *filename, const char *mode, struct dsf_file_info *info);
+
+ssize_t dsf_file_read(struct dsf_file *f, void *data, size_t samples, const struct dsf_layout *layout);
+
+int dsf_file_close(struct dsf_file *f);
+
diff --git a/src/tools/meson.build b/src/tools/meson.build
new file mode 100644
index 0000000..6623e7a
--- /dev/null
+++ b/src/tools/meson.build
@@ -0,0 +1,88 @@
+tools_sources = [
+  [ 'pw-mon', [ 'pw-mon.c' ] ],
+  [ 'pw-dot', [ 'pw-dot.c' ] ],
+  [ 'pw-dump', [ 'pw-dump.c' ] ],
+  [ 'pw-profiler', [ 'pw-profiler.c' ] ],
+  [ 'pw-mididump', [ 'pw-mididump.c', 'midifile.c' ] ],
+  [ 'pw-metadata', [ 'pw-metadata.c' ] ],
+  [ 'pw-loopback', [ 'pw-loopback.c' ] ],
+  [ 'pw-link', [ 'pw-link.c' ] ],
+]
+
+foreach t : tools_sources
+  executable(t.get(0),
+    t.get(1),
+    install: true,
+    dependencies : [pipewire_dep, mathlib],
+  )
+endforeach
+
+executable('pw-cli',
+  'pw-cli.c',
+  install: true,
+  dependencies: [pipewire_dep, readline_dep]
+)
+
+if ncurses_dep.found()
+  executable('pw-top',
+    'pw-top.c',
+    install: true,
+    dependencies : [pipewire_dep, ncurses_dep],
+  )
+endif
+
+build_pw_cat = false
+build_pw_cat_with_ffmpeg = false
+pwcat_deps = [ sndfile_dep ]
+
+if get_option('pw-cat').allowed() and sndfile_dep.found()
+  build_pw_cat = true
+
+  if pw_cat_ffmpeg.allowed() and avcodec_dep.found() and avformat_dep.found()
+    pwcat_deps += avcodec_dep
+    pwcat_deps += avformat_dep
+    build_pw_cat_with_ffmpeg = true
+  endif
+
+  pwcat_sources = [
+    'pw-cat.c',
+    'midifile.c',
+    'dsffile.c',
+  ]
+
+  pwcat_aliases = [
+    'pw-play',
+    'pw-record',
+    'pw-midiplay',
+    'pw-midirecord',
+    'pw-dsdplay',
+  ]
+
+  executable('pw-cat',
+    pwcat_sources,
+    install: true,
+    dependencies : [pwcat_deps, pipewire_dep, mathlib],
+  )
+
+  foreach alias : pwcat_aliases
+    dst = pipewire_bindir / alias
+    cmd = 'ln -fs @0@ $DESTDIR@1@'.format('pw-cat', dst)
+    meson.add_install_script('sh', '-c', cmd)
+  endforeach
+elif not sndfile_dep.found() and get_option('pw-cat').enabled()
+  error('pw-cat is enabled but required dependency `sndfile` was not found.')
+endif
+summary({'Build pw-cat tool': build_pw_cat}, bool_yn: true, section: 'pw-cat/pw-play/pw-dump tool')
+if build_pw_cat
+  summary({'Build pw-cat with FFmpeg integration': build_pw_cat_with_ffmpeg}, bool_yn: true, section: 'pw-cat/pw-play/pw-dump tool')
+endif
+
+if dbus_dep.found()
+  executable('pw-reserve',
+    'reserve.h',
+    'reserve.c',
+    'pw-reserve.c',
+    install: true,
+    dependencies : [dbus_dep, pipewire_dep],
+  )
+endif
diff --git a/src/tools/midifile.c b/src/tools/midifile.c
new file mode 100644
index 0000000..5276ade
--- /dev/null
+++ b/src/tools/midifile.c
@@ -0,0 +1,740 @@
+/* PipeWire
+ *
+ * Copyright © 2020 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 <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <math.h>
+
+#include <spa/utils/string.h>
+
+#include "midifile.h"
+
+#define DEFAULT_TEMPO	500000	/* 500ms per quarter note (120 BPM) is the default */
+
+struct midi_track {
+	uint16_t id;
+
+	uint8_t *data;
+	uint32_t size;
+
+	uint8_t *p;
+	int64_t tick;
+	unsigned int eof:1;
+	uint8_t event[4];
+};
+
+struct midi_file {
+	uint8_t *data;
+	size_t size;
+
+	int mode;
+	int fd;
+
+	struct midi_file_info info;
+	uint32_t length;
+	uint32_t tempo;
+
+	uint8_t *p;
+	int64_t tick;
+	double tick_sec;
+	double tick_start;
+
+	struct midi_track tracks[64];
+};
+
+static inline uint16_t parse_be16(const uint8_t *in)
+{
+	return (in[0] << 8) | in[1];
+}
+
+static inline uint32_t parse_be32(const uint8_t *in)
+{
+	return (in[0] << 24) | (in[1] << 16) | (in[2] << 8) | in[3];
+}
+
+static inline int mf_avail(struct midi_file *mf)
+{
+	if (mf->p < mf->data + mf->size)
+		return mf->size + mf->data - mf->p;
+	return 0;
+}
+
+static inline int tr_avail(struct midi_track *tr)
+{
+	if (tr->eof)
+		return 0;
+	if (tr->p < tr->data + tr->size)
+		return tr->size + tr->data - tr->p;
+	tr->eof = true;
+	return 0;
+}
+
+static int read_mthd(struct midi_file *mf)
+{
+	if (mf_avail(mf) < 14 ||
+	    memcmp(mf->p, "MThd", 4) != 0)
+		return -EINVAL;
+
+	mf->length = parse_be32(mf->p + 4);
+	mf->info.format = parse_be16(mf->p + 8);
+	mf->info.ntracks = parse_be16(mf->p + 10);
+	mf->info.division = parse_be16(mf->p + 12);
+
+	mf->p += 14;
+	return 0;
+}
+
+static int read_mtrk(struct midi_file *mf, struct midi_track *track)
+{
+	if (mf_avail(mf) < 8 ||
+	    memcmp(mf->p, "MTrk", 4) != 0)
+		return -EINVAL;
+
+	track->data = track->p = mf->p + 8;
+	track->size = parse_be32(mf->p + 4);
+
+	mf->p = track->data + track->size;
+	if (mf->p > mf->data + mf->size)
+		return -EINVAL;
+
+	return 0;
+}
+
+static int parse_varlen(struct midi_file *mf, struct midi_track *tr, uint32_t *result)
+{
+	uint32_t value = 0;
+
+	while (tr_avail(tr) > 0) {
+		uint8_t b = *tr->p++;
+		value = (value << 7) | (b & 0x7f);
+		if ((b & 0x80) == 0)
+			break;
+	}
+	*result = value;
+	return 0;
+}
+
+static int open_read(struct midi_file *mf, const char *filename, struct midi_file_info *info)
+{
+	int res;
+	uint16_t i;
+	struct stat st;
+
+	if ((mf->fd = open(filename, O_RDONLY)) < 0) {
+		res = -errno;
+		goto exit;
+	}
+	if (fstat(mf->fd, &st) < 0) {
+		res = -errno;
+		goto exit_close;
+	}
+	mf->size = st.st_size;
+
+	mf->data = mmap(NULL, mf->size, PROT_READ, MAP_SHARED, mf->fd, 0);
+	if (mf->data == MAP_FAILED) {
+		res = -errno;
+		goto exit_close;
+	}
+
+	mf->p = mf->data;
+
+	if ((res = read_mthd(mf)) < 0)
+		goto exit_unmap;
+
+	mf->tempo = DEFAULT_TEMPO;
+	mf->tick = 0;
+
+	for (i = 0; i < mf->info.ntracks; i++) {
+		struct midi_track *tr = &mf->tracks[i];
+		uint32_t delta_time;
+
+		if ((res = read_mtrk(mf, tr)) < 0)
+			goto exit_unmap;
+
+		if ((res = parse_varlen(mf, tr, &delta_time)) < 0)
+			goto exit_unmap;
+
+		tr->tick = delta_time;
+		tr->id = i;
+	}
+	mf->mode = 1;
+	*info = mf->info;
+	return 0;
+
+exit_unmap:
+	munmap(mf->data, mf->size);
+exit_close:
+	close(mf->fd);
+exit:
+	return res;
+}
+
+static inline int write_n(int fd, const void *buf, int count)
+{
+	return write(fd, buf, count) == (ssize_t)count ? count : -errno;
+}
+
+static inline int write_be16(int fd, uint16_t val)
+{
+	uint8_t buf[2] = { val >> 8, val };
+	return write_n(fd, buf, 2);
+}
+
+static inline int write_be32(int fd, uint32_t val)
+{
+	uint8_t buf[4] = { val >> 24, val >> 16, val >> 8, val };
+	return write_n(fd, buf, 4);
+}
+
+#define CHECK_RES(expr) if ((res = (expr)) < 0) return res
+
+static int write_headers(struct midi_file *mf)
+{
+	struct midi_track *tr = &mf->tracks[0];
+	int res;
+
+	lseek(mf->fd, 0, SEEK_SET);
+
+	mf->length = 6;
+	CHECK_RES(write_n(mf->fd, "MThd", 4));
+	CHECK_RES(write_be32(mf->fd, mf->length));
+	CHECK_RES(write_be16(mf->fd, mf->info.format));
+	CHECK_RES(write_be16(mf->fd, mf->info.ntracks));
+	CHECK_RES(write_be16(mf->fd, mf->info.division));
+
+	CHECK_RES(write_n(mf->fd, "MTrk", 4));
+	CHECK_RES(write_be32(mf->fd, tr->size));
+
+	return 0;
+}
+
+static int open_write(struct midi_file *mf, const char *filename, struct midi_file_info *info)
+{
+	int res;
+
+	if (info->format != 0)
+		return -EINVAL;
+	if (info->ntracks == 0)
+		info->ntracks = 1;
+	else if (info->ntracks != 1)
+		return -EINVAL;
+	if (info->division == 0)
+		info->division = 96;
+
+	if ((mf->fd = open(filename, O_WRONLY | O_CREAT, 0660)) < 0) {
+		res = -errno;
+		goto exit;
+	}
+	mf->mode = 2;
+	mf->tempo = DEFAULT_TEMPO;
+	mf->info = *info;
+
+	res = write_headers(mf);
+exit:
+	return res;
+}
+
+struct midi_file *
+midi_file_open(const char *filename, const char *mode, struct midi_file_info *info)
+{
+	int res;
+	struct midi_file *mf;
+
+	mf = calloc(1, sizeof(struct midi_file));
+	if (mf == NULL)
+		return NULL;
+
+	if (spa_streq(mode, "r")) {
+		if ((res = open_read(mf, filename, info)) < 0)
+			goto exit_free;
+	} else if (spa_streq(mode, "w")) {
+		if ((res = open_write(mf, filename, info)) < 0)
+			goto exit_free;
+	} else {
+		res = -EINVAL;
+		goto exit_free;
+	}
+	return mf;
+
+exit_free:
+	free(mf);
+	errno = -res;
+	return NULL;
+}
+
+int midi_file_close(struct midi_file *mf)
+{
+	int res;
+
+	if (mf->mode == 1) {
+		munmap(mf->data, mf->size);
+	} else if (mf->mode == 2) {
+		uint8_t buf[4] = { 0x00, 0xff, 0x2f, 0x00 };
+		CHECK_RES(write_n(mf->fd, buf, 4));
+		mf->tracks[0].size += 4;
+		CHECK_RES(write_headers(mf));
+	} else
+		return -EINVAL;
+
+	close(mf->fd);
+	free(mf);
+	return 0;
+}
+
+static int peek_next(struct midi_file *mf, struct midi_event *ev)
+{
+	struct midi_track *tr, *found = NULL;
+	uint16_t i;
+
+	for (i = 0; i < mf->info.ntracks; i++) {
+		tr = &mf->tracks[i];
+		if (tr_avail(tr) == 0)
+			continue;
+		if (found == NULL || tr->tick < found->tick)
+			found = tr;
+	}
+	if (found == NULL)
+		return 0;
+
+	ev->track = found->id;
+	ev->sec = mf->tick_sec + ((found->tick - mf->tick_start) * (double)mf->tempo) / (1000000.0 * mf->info.division);
+	return 1;
+}
+
+int midi_file_next_time(struct midi_file *mf, double *sec)
+{
+	struct midi_event ev;
+	int res;
+
+	if ((res = peek_next(mf, &ev)) <= 0)
+		return res;
+
+	*sec = ev.sec;
+	return 1;
+}
+
+int midi_file_read_event(struct midi_file *mf, struct midi_event *event)
+{
+	struct midi_track *tr;
+	uint32_t delta_time, size;
+	uint8_t status, meta;
+	int res, running;
+
+	if ((res = peek_next(mf, event)) <= 0)
+		return res;
+
+	tr = &mf->tracks[event->track];
+	status = *tr->p;
+
+	running = (status & 0x80) == 0;
+	if (running) {
+		status = tr->event[0];
+		event->data = tr->event;
+	} else {
+		event->data = tr->p++;
+		tr->event[0] = status;
+	}
+
+	switch (status) {
+	case 0xc0 ... 0xdf:
+		size = 2;
+		break;
+
+	case 0x80 ... 0xbf:
+	case 0xe0 ... 0xef:
+		size = 3;
+		break;
+
+	case 0xff:
+		meta = *tr->p++;
+
+		if ((res = parse_varlen(mf, tr, &size)) < 0)
+			return res;
+
+		event->meta.offset = tr->p - event->data;
+		event->meta.size = size;
+
+		switch (meta) {
+		case 0x2f:
+			tr->eof = true;
+			break;
+		case 0x51:
+			if (size < 3)
+				return -EINVAL;
+			mf->tick_sec = event->sec;
+			mf->tick_start = tr->tick;
+			event->meta.parsed.tempo.uspqn = mf->tempo = (tr->p[0]<<16) | (tr->p[1]<<8) | tr->p[2];
+			break;
+		}
+		size += tr->p - event->data;
+		break;
+
+	case 0xf0:
+	case 0xf7:
+		if ((res = parse_varlen(mf, tr, &size)) < 0)
+			return res;
+		size += tr->p - event->data;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	event->size = size;
+
+	if (running) {
+		memcpy(&event->data[1], tr->p, size - 1);
+		tr->p += size - 1;
+	} else {
+		tr->p = event->data + event->size;
+	}
+
+	if ((res = parse_varlen(mf, tr, &delta_time)) < 0)
+		return res;
+
+	tr->tick += delta_time;
+	return 1;
+}
+
+static int write_varlen(struct midi_file *mf, struct midi_track *tr, uint32_t value)
+{
+	uint64_t buffer;
+	uint8_t b;
+	int res;
+
+	buffer = value & 0x7f;
+	while ((value >>= 7)) {
+		buffer <<= 8;
+		buffer |= ((value & 0x7f) | 0x80);
+	}
+        do  {
+		b = buffer & 0xff;
+		CHECK_RES(write_n(mf->fd, &b, 1));
+		tr->size++;
+		buffer >>= 8;
+	} while (b & 0x80);
+
+	return 0;
+}
+
+int midi_file_write_event(struct midi_file *mf, const struct midi_event *event)
+{
+	struct midi_track *tr;
+	uint32_t tick;
+	int res;
+
+	spa_return_val_if_fail(event != NULL, -EINVAL);
+	spa_return_val_if_fail(mf != NULL, -EINVAL);
+	spa_return_val_if_fail(event->track == 0, -EINVAL);
+	spa_return_val_if_fail(event->size > 1, -EINVAL);
+
+	tr = &mf->tracks[event->track];
+
+	tick = event->sec * (1000000.0 * mf->info.division) / (double)mf->tempo;
+
+	CHECK_RES(write_varlen(mf, tr, tick - tr->tick));
+	tr->tick = tick;
+
+	CHECK_RES(write_n(mf->fd, event->data, event->size));
+	tr->size += event->size;
+
+	return 0;
+}
+
+static const char * const event_names[] = {
+	"Text", "Copyright", "Sequence/Track Name",
+	"Instrument", "Lyric", "Marker", "Cue Point",
+	"Program Name", "Device (Port) Name"
+};
+
+static const char * const note_names[] = {
+	"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
+};
+
+static const char * const controller_names[128] = {
+	[0] =	"Bank Select (coarse)",
+	[1] =	"Modulation Wheel (coarse)",
+	[2] =	"Breath controller (coarse)",
+	[4] =	"Foot Pedal (coarse)",
+	[5] =	"Portamento Time (coarse)",
+	[6] =	"Data Entry (coarse)",
+	[7] =	"Volume (coarse)",
+	[8] =	"Balance (coarse)",
+	[10] =	"Pan position (coarse)",
+	[11] =	"Expression (coarse)",
+	[12] =	"Effect Control 1 (coarse)",
+	[13] =	"Effect Control 2 (coarse)",
+	[16] =	"General Purpose Slider 1",
+	[17] =	"General Purpose Slider 2",
+	[18] =	"General Purpose Slider 3",
+	[19] =	"General Purpose Slider 4",
+	[32] =	"Bank Select (fine)",
+	[33] =	"Modulation Wheel (fine)",
+	[34] =	"Breath 	 (fine)",
+	[36] =	"Foot Pedal (fine)",
+	[37] =	"Portamento Time (fine)",
+	[38] =	"Data Entry (fine)",
+	[39] =	"Volume (fine)",
+	[40] =	"Balance (fine)",
+	[42] =	"Pan position (fine)",
+	[43] =	"Expression (fine)",
+	[44] =	"Effect Control 1 (fine)",
+	[45] =	"Effect Control 2 (fine)",
+	[64] =	"Hold Pedal (on/off)",
+	[65] =	"Portamento (on/off)",
+	[66] =	"Sustenuto Pedal (on/off)",
+	[67] =	"Soft Pedal (on/off)",
+	[68] =	"Legato Pedal (on/off)",
+	[69] =	"Hold 2 Pedal (on/off)",
+	[70] =	"Sound Variation",
+	[71] =	"Sound Timbre",
+	[72] =	"Sound Release Time",
+	[73] =	"Sound Attack Time",
+	[74] =	"Sound Brightness",
+	[75] =	"Sound Control 6",
+	[76] =	"Sound Control 7",
+	[77] =	"Sound Control 8",
+	[78] =	"Sound Control 9",
+	[79] =	"Sound Control 10",
+	[80] =	"General Purpose Button 1 (on/off)",
+	[81] =	"General Purpose Button 2 (on/off)",
+	[82] =	"General Purpose Button 3 (on/off)",
+	[83] =	"General Purpose Button 4 (on/off)",
+	[91] =	"Effects Level",
+	[92] =	"Tremulo Level",
+	[93] =	"Chorus Level",
+	[94] =	"Celeste Level",
+	[95] =	"Phaser Level",
+	[96] =	"Data Button increment",
+	[97] =	"Data Button decrement",
+	[98] =	"Non-registered Parameter (fine)",
+	[99] =	"Non-registered Parameter (coarse)",
+	[100] =	"Registered Parameter (fine)",
+	[101] =	"Registered Parameter (coarse)",
+	[120] =	"All Sound Off",
+	[121] =	"All Controllers Off",
+	[122] =	"Local Keyboard (on/off)",
+	[123] =	"All Notes Off",
+	[124] =	"Omni Mode Off",
+	[125] =	"Omni Mode On",
+	[126] =	"Mono Operation",
+	[127] =	"Poly Operation",
+};
+
+static const char * const program_names[] = {
+	"Acoustic Grand", "Bright Acoustic", "Electric Grand", "Honky-Tonk",
+	"Electric Piano 1", "Electric Piano 2", "Harpsichord", "Clavinet",
+	"Celesta", "Glockenspiel", "Music Box", "Vibraphone", "Marimba",
+	"Xylophone", "Tubular Bells", "Dulcimer", "Drawbar Organ", "Percussive Organ",
+	"Rock Organ", "Church Organ", "Reed Organ", "Accoridan", "Harmonica",
+	"Tango Accordion", "Nylon String Guitar", "Steel String Guitar",
+	"Electric Jazz Guitar", "Electric Clean Guitar", "Electric Muted Guitar",
+	"Overdriven Guitar", "Distortion Guitar", "Guitar Harmonics",
+	"Acoustic Bass", "Electric Bass (fingered)", "Electric Bass (picked)",
+	"Fretless Bass", "Slap Bass 1", "Slap Bass 2", "Synth Bass 1", "Synth Bass 2",
+	"Violin", "Viola", "Cello", "Contrabass", "Tremolo Strings", "Pizzicato Strings",
+	"Orchestral Strings", "Timpani", "String Ensemble 1", "String Ensemble 2",
+	"SynthStrings 1", "SynthStrings 2", "Choir Aahs", "Voice Oohs", "Synth Voice",
+	"Orchestra Hit", "Trumpet", "Trombone", "Tuba", "Muted Trumpet", "French Horn",
+	"Brass Section", "SynthBrass 1", "SynthBrass 2", "Soprano Sax", "Alto Sax",
+	"Tenor Sax", "Baritone Sax", "Oboe", "English Horn", "Bassoon", "Clarinet",
+	"Piccolo", "Flute", "Recorder", "Pan Flute", "Blown Bottle", "Skakuhachi",
+	"Whistle", "Ocarina", "Lead 1 (square)", "Lead 2 (sawtooth)", "Lead 3 (calliope)",
+	"Lead 4 (chiff)", "Lead 5 (charang)", "Lead 6 (voice)", "Lead 7 (fifths)",
+	"Lead 8 (bass+lead)", "Pad 1 (new age)", "Pad 2 (warm)", "Pad 3 (polysynth)",
+	"Pad 4 (choir)", "Pad 5 (bowed)", "Pad 6 (metallic)", "Pad 7 (halo)",
+	"Pad 8 (sweep)", "FX 1 (rain)", "FX 2 (soundtrack)", "FX 3 (crystal)",
+	"FX 4 (atmosphere)", "FX 5 (brightness)", "FX 6 (goblins)", "FX 7 (echoes)",
+	"FX 8 (sci-fi)", "Sitar", "Banjo", "Shamisen", "Koto", "Kalimba", "Bagpipe",
+	"Fiddle", "Shanai", "Tinkle Bell", "Agogo", "Steel Drums", "Woodblock",
+	"Taiko Drum", "Melodic Tom", "Synth Drum", "Reverse Cymbal", "Guitar Fret Noise",
+	"Breath Noise", "Seashore", "Bird Tweet", "Telephone Ring", "Helicopter",
+	"Applause", "Gunshot"
+};
+
+static const char * const smpte_rates[] = {
+	"24 fps",
+	"25 fps",
+	"30 fps (drop frame)",
+	"30 fps (non drop frame)"
+};
+
+static const char * const major_keys[] = {
+	"Unknown major", "Fb", "Cb", "Gb", "Db", "Ab", "Eb", "Bb", "F",
+	"C", "G", "D", "A", "E", "B", "F#", "C#", "G#", "Unknown major"
+};
+
+static const char * const minor_keys[] = {
+	"Unknown minor", "Dbm", "Abm", "Ebm", "Bbm", "Fm", "Cm", "Gm", "Dm",
+	"Am", "Em", "Bm", "F#m", "C#m", "G#m", "D#m", "A#m", "E#m", "Unknown minor"
+};
+
+static const char *controller_name(uint8_t ctrl)
+{
+	if (ctrl > 127 ||
+	    controller_names[ctrl] == NULL)
+		return "Unknown";
+	return controller_names[ctrl];
+}
+
+static void dump_mem(FILE *out, const char *label, uint8_t *data, uint32_t size)
+{
+	fprintf(out, "%s: ", label);
+	while (size--)
+		fprintf(out, "%02x ", *data++);
+}
+
+int midi_file_dump_event(FILE *out, const struct midi_event *ev)
+{
+	fprintf(out, "track:%2d sec:%f ", ev->track, ev->sec);
+
+	switch (ev->data[0]) {
+	case 0x80 ... 0x8f:
+		fprintf(out, "Note Off   (channel %2d): note %3s%d, velocity %3d",
+				(ev->data[0] & 0x0f) + 1,
+				note_names[ev->data[1] % 12], ev->data[1] / 12 -1,
+				ev->data[2]);
+		break;
+	case 0x90 ... 0x9f:
+		fprintf(out, "Note On    (channel %2d): note %3s%d, velocity %3d",
+				(ev->data[0] & 0x0f) + 1,
+				note_names[ev->data[1] % 12], ev->data[1] / 12 -1,
+				ev->data[2]);
+		break;
+	case 0xa0 ... 0xaf:
+		fprintf(out, "Aftertouch (channel %2d): note %3s%d, pressure %3d",
+				(ev->data[0] & 0x0f) + 1,
+				note_names[ev->data[1] % 12], ev->data[1] / 12 -1,
+				ev->data[2]);
+		break;
+	case 0xb0 ... 0xbf:
+		fprintf(out, "Controller (channel %2d): controller %3d (%s), value %3d",
+				(ev->data[0] & 0x0f) + 1, ev->data[1],
+				controller_name(ev->data[1]), ev->data[2]);
+		break;
+	case 0xc0 ... 0xcf:
+		fprintf(out, "Program    (channel %2d): program %3d (%s)",
+				(ev->data[0] & 0x0f) + 1, ev->data[1],
+				program_names[ev->data[1]]);
+		break;
+	case 0xd0 ... 0xdf:
+		fprintf(out, "Channel Pressure (channel %2d): pressure %3d",
+				(ev->data[0] & 0x0f) + 1, ev->data[1]);
+		break;
+	case 0xe0 ... 0xef:
+		fprintf(out, "Pitch Bend (channel %2d): value %d", (ev->data[0] & 0x0f) + 1,
+				((int)ev->data[2] << 7 | ev->data[1]) - 0x2000);
+		break;
+	case 0xf0:
+	case 0xf7:
+		dump_mem(out, "SysEx", ev->data, ev->size);
+		break;
+	case 0xf1:
+		fprintf(out, "MIDI Time Code Quarter Frame: type %d values %d",
+				ev->data[0] >> 4, ev->data[0] & 0xf);
+		break;
+	case 0xf2:
+		fprintf(out, "Song Position Pointer: value %d",
+				((int)ev->data[1] << 7 | ev->data[0]));
+		break;
+	case 0xf3:
+		fprintf(out, "Song Select: value %d", (ev->data[0] & 0x7f));
+		break;
+	case 0xf6:
+		fprintf(out, "Tune Request");
+		break;
+	case 0xf8:
+		fprintf(out, "Timing Clock");
+		break;
+	case 0xfa:
+		fprintf(out, "Start Sequence");
+		break;
+	case 0xfb:
+		fprintf(out, "Continue Sequence");
+		break;
+	case 0xfc:
+		fprintf(out, "Stop Sequence");
+		break;
+	case 0xfe:
+		fprintf(out, "Active Sensing");
+		break;
+	case 0xff:
+		fprintf(out, "Meta: ");
+		switch (ev->data[1]) {
+		case 0x00:
+			fprintf(out, "Sequence Number %3d %3d", ev->data[3], ev->data[4]);
+			break;
+		case 0x01 ... 0x09:
+			fprintf(out, "%s: %s", event_names[ev->data[1] - 1], &ev->data[ev->meta.offset]);
+			break;
+		case 0x20:
+			fprintf(out, "Channel Prefix: %03d", ev->data[3]);
+			break;
+		case 0x21:
+			fprintf(out, "Midi Port: %03d", ev->data[3]);
+			break;
+		case 0x2f:
+			fprintf(out, "End Of Track");
+			break;
+		case 0x51:
+			fprintf(out, "Tempo: %d microseconds per quarter note, %.2f BPM",
+					ev->meta.parsed.tempo.uspqn,
+					60000000.0 / (double)ev->meta.parsed.tempo.uspqn);
+			break;
+		case 0x54:
+			fprintf(out, "SMPTE Offset: %s %02d:%02d:%02d:%02d.%03d",
+					smpte_rates[(ev->data[3] & 0x60) >> 5],
+					ev->data[3] & 0x1f, ev->data[4], ev->data[5],
+					ev->data[6], ev->data[7]);
+			break;
+		case 0x58:
+			fprintf(out, "Time Signature: %d/%d, %d clocks per click, %d notated 32nd notes per quarter note",
+				ev->data[3], (int)pow(2, ev->data[4]), ev->data[5], ev->data[6]);
+			break;
+		case 0x59:
+		{
+			int sf = ev->data[3];
+			fprintf(out, "Key Signature: %d %s: %s", abs(sf),
+					sf > 0 ? "sharps" : "flats",
+					ev->data[4] == 0 ?
+						major_keys[SPA_CLAMP(sf + 9, 0, 18)] :
+						minor_keys[SPA_CLAMP(sf + 9, 0, 18)]);
+			break;
+		}
+		case 0x7f:
+			dump_mem(out, "Sequencer", ev->data, ev->size);
+			break;
+		default:
+			dump_mem(out, "Invalid", ev->data, ev->size);
+		}
+		break;
+	default:
+		dump_mem(out, "Unknown", ev->data, ev->size);
+		break;
+	}
+	fprintf(out, "\n");
+	return 0;
+}
diff --git a/src/tools/midifile.h b/src/tools/midifile.h
new file mode 100644
index 0000000..6c69df4
--- /dev/null
+++ b/src/tools/midifile.h
@@ -0,0 +1,64 @@
+/* PipeWire
+ *
+ * Copyright © 2020 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 <stdio.h>
+
+#include <spa/utils/defs.h>
+
+struct midi_file;
+
+struct midi_event {
+	uint32_t track;
+	double sec;
+	uint8_t *data;
+	uint32_t size;
+	struct {
+		uint32_t offset;
+		uint32_t size;
+		union {
+			struct {
+				uint32_t uspqn; /* microseconds per quarter note */
+			} tempo;
+		} parsed;
+	} meta;
+};
+
+struct midi_file_info {
+	uint16_t format;
+	uint16_t ntracks;
+	uint16_t division;
+};
+
+struct midi_file *
+midi_file_open(const char *filename, const char *mode, struct midi_file_info *info);
+
+int midi_file_close(struct midi_file *mf);
+
+int midi_file_next_time(struct midi_file *mf, double *sec);
+
+int midi_file_read_event(struct midi_file *mf, struct midi_event *event);
+
+int midi_file_write_event(struct midi_file *mf, const struct midi_event *event);
+
+int midi_file_dump_event(FILE *out, const struct midi_event *event);
diff --git a/src/tools/pw-cat.c b/src/tools/pw-cat.c
new file mode 100644
index 0000000..068fac1
--- /dev/null
+++ b/src/tools/pw-cat.c
@@ -0,0 +1,1971 @@
+/* PipeWire - pw-cat
+ *
+ * Copyright © 2020 Konsulko Group
+
+ * Author: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
+ *
+ * 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 <stdio.h>
+#include <errno.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <assert.h>
+#include <ctype.h>
+#include <locale.h>
+
+#include <sndfile.h>
+
+#include <spa/param/audio/layout.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/audio/type-info.h>
+#include <spa/param/props.h>
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/utils/json.h>
+#include <spa/debug/types.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/i18n.h>
+#include <pipewire/extensions/metadata.h>
+
+#include "config.h"
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+#endif
+
+#include "midifile.h"
+#include "dsffile.h"
+
+#define DEFAULT_MEDIA_TYPE	"Audio"
+#define DEFAULT_MIDI_MEDIA_TYPE	"Midi"
+#define DEFAULT_MEDIA_CATEGORY_PLAYBACK	"Playback"
+#define DEFAULT_MEDIA_CATEGORY_RECORD	"Capture"
+#define DEFAULT_MEDIA_ROLE	"Music"
+#define DEFAULT_TARGET		"auto"
+#define DEFAULT_LATENCY_PLAY	"100ms"
+#define DEFAULT_LATENCY_REC	"none"
+#define DEFAULT_RATE		48000
+#define DEFAULT_CHANNELS	2
+#define DEFAULT_FORMAT		"s16"
+#define DEFAULT_VOLUME		1.0
+#define DEFAULT_QUALITY		4
+
+enum mode {
+	mode_none,
+	mode_playback,
+	mode_record
+};
+
+enum unit {
+	unit_none,
+	unit_samples,
+	unit_sec,
+	unit_msec,
+	unit_usec,
+	unit_nsec,
+};
+
+struct data;
+
+typedef int (*fill_fn)(struct data *d, void *dest, unsigned int n_frames);
+
+struct channelmap {
+	int n_channels;
+	int channels[SPA_AUDIO_MAX_CHANNELS];
+};
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_stream *stream;
+	struct spa_hook stream_listener;
+
+	struct spa_source *timer;
+
+	enum mode mode;
+	bool verbose;
+#define TYPE_PCM	0
+#define TYPE_MIDI	1
+#define TYPE_DSD	2
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+#define TYPE_ENCODED    3
+#endif
+	int data_type;
+	const char *remote_name;
+	const char *media_type;
+	const char *media_category;
+	const char *media_role;
+	const char *channel_map;
+	const char *format;
+	const char *target;
+	const char *latency;
+	struct pw_properties *props;
+
+	const char *filename;
+	SNDFILE *file;
+
+	unsigned int bitrate;
+	unsigned int rate;
+	int channels;
+	struct channelmap channelmap;
+	unsigned int stride;
+	enum unit latency_unit;
+	unsigned int latency_value;
+	int quality;
+
+	enum spa_audio_format spa_format;
+
+	float volume;
+	bool volume_is_set;
+
+	fill_fn fill;
+
+	struct spa_io_position *position;
+	bool drained;
+	uint64_t clock_time;
+
+	struct {
+		struct midi_file *file;
+		struct midi_file_info info;
+	} midi;
+	struct {
+		struct dsf_file *file;
+		struct dsf_file_info info;
+		struct dsf_layout layout;
+	} dsf;
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+	FILE *encoded_file;
+	AVFormatContext *fmt_context;
+	AVStream *astream;
+	AVCodecContext *ctx;
+	enum AVSampleFormat sfmt;
+#endif
+};
+
+#define STR_FMTS "(ulaw|alaw|u8|s8|s16|s32|f32|f64)"
+
+static const struct format_info {
+	const char *name;
+	int sf_format;
+	uint32_t spa_format;
+	uint32_t width;
+} format_info[] = {
+	{  "ulaw", SF_FORMAT_ULAW, SPA_AUDIO_FORMAT_ULAW, 1 },
+	{  "alaw", SF_FORMAT_ULAW, SPA_AUDIO_FORMAT_ALAW, 1 },
+	{  "s8", SF_FORMAT_PCM_S8, SPA_AUDIO_FORMAT_S8, 1 },
+	{  "u8", SF_FORMAT_PCM_U8, SPA_AUDIO_FORMAT_U8, 1 },
+	{  "s16", SF_FORMAT_PCM_16, SPA_AUDIO_FORMAT_S16, 2 },
+	{  "s24", SF_FORMAT_PCM_24, SPA_AUDIO_FORMAT_S24, 3 },
+	{  "s32", SF_FORMAT_PCM_32, SPA_AUDIO_FORMAT_S32, 4 },
+	{  "f32", SF_FORMAT_FLOAT, SPA_AUDIO_FORMAT_F32, 4 },
+	{  "f64", SF_FORMAT_DOUBLE, SPA_AUDIO_FORMAT_F32, 8 },
+};
+
+static const struct format_info *format_info_by_name(const char *str)
+{
+	SPA_FOR_EACH_ELEMENT_VAR(format_info, i)
+		if (spa_streq(str, i->name))
+			return i;
+	return NULL;
+}
+
+static const struct format_info *format_info_by_sf_format(int format)
+{
+	int sub_type = (format & SF_FORMAT_SUBMASK);
+	SPA_FOR_EACH_ELEMENT_VAR(format_info, i)
+		if (i->sf_format == sub_type)
+			return i;
+	return NULL;
+}
+
+static int sf_playback_fill_x8(struct data *d, void *dest, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	rn = sf_read_raw(d->file, dest, n_frames * d->stride);
+	return (int)rn / d->stride;
+}
+
+static int sf_playback_fill_s16(struct data *d, void *dest, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(short) == sizeof(int16_t));
+	rn = sf_readf_short(d->file, dest, n_frames);
+	return (int)rn;
+}
+
+static int sf_playback_fill_s32(struct data *d, void *dest, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(int) == sizeof(int32_t));
+	rn = sf_readf_int(d->file, dest, n_frames);
+	return (int)rn;
+}
+
+static int sf_playback_fill_f32(struct data *d, void *dest, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(float) == 4);
+	rn = sf_readf_float(d->file, dest, n_frames);
+	return (int)rn;
+}
+
+static int sf_playback_fill_f64(struct data *d, void *dest, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(double) == 8);
+	rn = sf_readf_double(d->file, dest, n_frames);
+	return (int)rn;
+}
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+static int encoded_playback_fill(struct data *d, void *dest, unsigned int n_frames)
+{
+	int ret, size = 0;
+	uint8_t buffer[16384] = { 0 };
+
+	ret = fread(buffer, 1, 16384, d->encoded_file);
+	if (ret > 0) {
+		memcpy(dest, buffer, ret);
+		size = ret;
+	}
+
+	return (int)size;
+}
+
+static int avcodec_ctx_to_info(struct data *data, AVCodecContext *ctx, struct spa_audio_info *info)
+{
+	int32_t profile;
+
+	switch (ctx->codec_id) {
+	case AV_CODEC_ID_VORBIS:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_vorbis;
+		info->info.vorbis.rate = data->rate;
+		info->info.vorbis.channels = data->channels;
+		break;
+	case AV_CODEC_ID_MP3:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_mp3;
+		info->info.mp3.rate = data->rate;
+		info->info.mp3.channels = data->channels;
+		break;
+	case AV_CODEC_ID_AAC:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_aac;
+		info->info.aac.rate = data->rate;
+		info->info.aac.channels = data->channels;
+		info->info.aac.bitrate = data->bitrate;
+		info->info.aac.stream_format = SPA_AUDIO_AAC_STREAM_FORMAT_RAW;
+		break;
+	case AV_CODEC_ID_WMAV1:
+	case AV_CODEC_ID_WMAV2:
+	case AV_CODEC_ID_WMAPRO:
+	case AV_CODEC_ID_WMAVOICE:
+	case AV_CODEC_ID_WMALOSSLESS:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_wma;
+		switch (ctx->codec_tag) {
+		/* TODO see if these hex constants can be replaced by named constants from FFmpeg */
+		case 0x161:
+			profile = SPA_AUDIO_WMA_PROFILE_WMA9;
+			break;
+		case 0x162:
+			profile = SPA_AUDIO_WMA_PROFILE_WMA9_PRO;
+			break;
+		case 0x163:
+			profile = SPA_AUDIO_WMA_PROFILE_WMA9_LOSSLESS;
+			break;
+		case 0x166:
+			profile = SPA_AUDIO_WMA_PROFILE_WMA10;
+			break;
+		case 0x167:
+			profile = SPA_AUDIO_WMA_PROFILE_WMA10_LOSSLESS;
+			break;
+		default:
+			fprintf(stderr, "error: invalid WMA profile\n");
+			return -EINVAL;
+		}
+		info->info.wma.rate = data->rate;
+		info->info.wma.channels = data->channels;
+		info->info.wma.bitrate = data->bitrate;
+		info->info.wma.block_align = ctx->block_align;
+		info->info.wma.profile = profile;
+		break;
+	case AV_CODEC_ID_FLAC:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_flac;
+		info->info.flac.rate = data->rate;
+		info->info.flac.channels = data->channels;
+		break;
+	case AV_CODEC_ID_ALAC:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_alac;
+		info->info.alac.rate = data->rate;
+		info->info.alac.channels = data->channels;
+		break;
+	case AV_CODEC_ID_APE:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_ape;
+		info->info.ape.rate = data->rate;
+		info->info.ape.channels = data->channels;
+		break;
+	case AV_CODEC_ID_RA_144:
+	case AV_CODEC_ID_RA_288:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_ra;
+		info->info.ra.rate = data->rate;
+		info->info.ra.channels = data->channels;
+		break;
+	case AV_CODEC_ID_AMR_NB:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_amr;
+		info->info.amr.rate = data->rate;
+		info->info.amr.channels = data->channels;
+		info->info.amr.band_mode = SPA_AUDIO_AMR_BAND_MODE_NB;
+		break;
+	case AV_CODEC_ID_AMR_WB:
+		info->media_subtype = SPA_MEDIA_SUBTYPE_amr;
+		info->info.amr.rate = data->rate;
+		info->info.amr.channels = data->channels;
+		info->info.amr.band_mode = SPA_AUDIO_AMR_BAND_MODE_WB;
+		break;
+	default:
+		fprintf(stderr, "Unsupported encoded media subtype\n");
+		return -EINVAL;
+	}
+	return 0;
+}
+#endif
+
+static inline fill_fn
+playback_fill_fn(uint32_t fmt)
+{
+	switch (fmt) {
+	case SPA_AUDIO_FORMAT_S8:
+	case SPA_AUDIO_FORMAT_U8:
+	case SPA_AUDIO_FORMAT_ULAW:
+	case SPA_AUDIO_FORMAT_ALAW:
+		return sf_playback_fill_x8;
+	case SPA_AUDIO_FORMAT_S16_LE:
+	case SPA_AUDIO_FORMAT_S16_BE:
+		/* sndfile check */
+		if (sizeof(int16_t) != sizeof(short))
+			return NULL;
+		return sf_playback_fill_s16;
+	case SPA_AUDIO_FORMAT_S32_LE:
+	case SPA_AUDIO_FORMAT_S32_BE:
+		/* sndfile check */
+		if (sizeof(int32_t) != sizeof(int))
+			return NULL;
+		return sf_playback_fill_s32;
+	case SPA_AUDIO_FORMAT_F32_LE:
+	case SPA_AUDIO_FORMAT_F32_BE:
+		/* sndfile check */
+		if (sizeof(float) != 4)
+			return NULL;
+		return sf_playback_fill_f32;
+	case SPA_AUDIO_FORMAT_F64_LE:
+	case SPA_AUDIO_FORMAT_F64_BE:
+		if (sizeof(double) != 8)
+			return NULL;
+		return sf_playback_fill_f64;
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+	case SPA_AUDIO_FORMAT_ENCODED:
+		return encoded_playback_fill;
+#endif
+	default:
+		break;
+	}
+	return NULL;
+}
+
+static int sf_record_fill_x8(struct data *d, void *src, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	rn = sf_write_raw(d->file, src, n_frames * d->stride);
+	return (int)rn / d->stride;
+}
+
+static int sf_record_fill_s16(struct data *d, void *src, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(short) == sizeof(int16_t));
+	rn = sf_writef_short(d->file, src, n_frames);
+	return (int)rn;
+}
+
+static int sf_record_fill_s32(struct data *d, void *src, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(int) == sizeof(int32_t));
+	rn = sf_writef_int(d->file, src, n_frames);
+	return (int)rn;
+}
+
+static int sf_record_fill_f32(struct data *d, void *src, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(float) == 4);
+	rn = sf_writef_float(d->file, src, n_frames);
+	return (int)rn;
+}
+
+static int sf_record_fill_f64(struct data *d, void *src, unsigned int n_frames)
+{
+	sf_count_t rn;
+
+	assert(sizeof(double) == 8);
+	rn = sf_writef_double(d->file, src, n_frames);
+	return (int)rn;
+}
+
+static inline fill_fn
+record_fill_fn(uint32_t fmt)
+{
+	switch (fmt) {
+	case SPA_AUDIO_FORMAT_S8:
+	case SPA_AUDIO_FORMAT_U8:
+	case SPA_AUDIO_FORMAT_ULAW:
+	case SPA_AUDIO_FORMAT_ALAW:
+		return sf_record_fill_x8;
+	case SPA_AUDIO_FORMAT_S16_LE:
+	case SPA_AUDIO_FORMAT_S16_BE:
+		/* sndfile check */
+		if (sizeof(int16_t) != sizeof(short))
+			return NULL;
+		return sf_record_fill_s16;
+	case SPA_AUDIO_FORMAT_S32_LE:
+	case SPA_AUDIO_FORMAT_S32_BE:
+		/* sndfile check */
+		if (sizeof(int32_t) != sizeof(int))
+			return NULL;
+		return sf_record_fill_s32;
+	case SPA_AUDIO_FORMAT_F32_LE:
+	case SPA_AUDIO_FORMAT_F32_BE:
+		/* sndfile check */
+		if (sizeof(float) != 4)
+			return NULL;
+		return sf_record_fill_f32;
+	case SPA_AUDIO_FORMAT_F64_LE:
+	case SPA_AUDIO_FORMAT_F64_BE:
+		/* sndfile check */
+		if (sizeof(double) != 8)
+			return NULL;
+		return sf_record_fill_f64;
+	default:
+		break;
+	}
+	return NULL;
+}
+
+static int channelmap_from_sf(struct channelmap *map)
+{
+	static const enum spa_audio_channel table[] = {
+		[SF_CHANNEL_MAP_MONO] =                  SPA_AUDIO_CHANNEL_MONO,
+		[SF_CHANNEL_MAP_LEFT] =                  SPA_AUDIO_CHANNEL_FL, /* libsndfile distinguishes left and front-left, which we don't */
+		[SF_CHANNEL_MAP_RIGHT] =                 SPA_AUDIO_CHANNEL_FR,
+		[SF_CHANNEL_MAP_CENTER] =                SPA_AUDIO_CHANNEL_FC,
+		[SF_CHANNEL_MAP_FRONT_LEFT] =            SPA_AUDIO_CHANNEL_FL,
+		[SF_CHANNEL_MAP_FRONT_RIGHT] =           SPA_AUDIO_CHANNEL_FR,
+		[SF_CHANNEL_MAP_FRONT_CENTER] =          SPA_AUDIO_CHANNEL_FC,
+		[SF_CHANNEL_MAP_REAR_CENTER] =           SPA_AUDIO_CHANNEL_RC,
+		[SF_CHANNEL_MAP_REAR_LEFT] =             SPA_AUDIO_CHANNEL_RL,
+		[SF_CHANNEL_MAP_REAR_RIGHT] =            SPA_AUDIO_CHANNEL_RR,
+		[SF_CHANNEL_MAP_LFE] =                   SPA_AUDIO_CHANNEL_LFE,
+		[SF_CHANNEL_MAP_FRONT_LEFT_OF_CENTER] =  SPA_AUDIO_CHANNEL_FLC,
+		[SF_CHANNEL_MAP_FRONT_RIGHT_OF_CENTER] = SPA_AUDIO_CHANNEL_FRC,
+		[SF_CHANNEL_MAP_SIDE_LEFT] =             SPA_AUDIO_CHANNEL_SL,
+		[SF_CHANNEL_MAP_SIDE_RIGHT] =            SPA_AUDIO_CHANNEL_SR,
+		[SF_CHANNEL_MAP_TOP_CENTER] =            SPA_AUDIO_CHANNEL_TC,
+		[SF_CHANNEL_MAP_TOP_FRONT_LEFT] =        SPA_AUDIO_CHANNEL_TFL,
+		[SF_CHANNEL_MAP_TOP_FRONT_RIGHT] =       SPA_AUDIO_CHANNEL_TFR,
+		[SF_CHANNEL_MAP_TOP_FRONT_CENTER] =      SPA_AUDIO_CHANNEL_TFC,
+		[SF_CHANNEL_MAP_TOP_REAR_LEFT] =         SPA_AUDIO_CHANNEL_TRL,
+		[SF_CHANNEL_MAP_TOP_REAR_RIGHT] =        SPA_AUDIO_CHANNEL_TRR,
+		[SF_CHANNEL_MAP_TOP_REAR_CENTER] =       SPA_AUDIO_CHANNEL_TRC
+	};
+	int i;
+
+	for (i = 0; i < map->n_channels; i++) {
+		if (map->channels[i] >= 0 && map->channels[i] < (int) SPA_N_ELEMENTS(table))
+			map->channels[i] = table[map->channels[i]];
+		else
+			map->channels[i] = SPA_AUDIO_CHANNEL_UNKNOWN;
+	}
+	return 0;
+}
+struct mapping {
+	const char *name;
+	unsigned int channels;
+	unsigned int values[32];
+};
+
+static const struct mapping maps[] =
+{
+	{ "mono",         SPA_AUDIO_LAYOUT_Mono },
+	{ "stereo",       SPA_AUDIO_LAYOUT_Stereo },
+	{ "surround-21",  SPA_AUDIO_LAYOUT_2_1 },
+	{ "quad",         SPA_AUDIO_LAYOUT_Quad },
+	{ "surround-22",  SPA_AUDIO_LAYOUT_2_2 },
+	{ "surround-40",  SPA_AUDIO_LAYOUT_4_0 },
+	{ "surround-31",  SPA_AUDIO_LAYOUT_3_1 },
+	{ "surround-41",  SPA_AUDIO_LAYOUT_4_1 },
+	{ "surround-50",  SPA_AUDIO_LAYOUT_5_0 },
+	{ "surround-51",  SPA_AUDIO_LAYOUT_5_1 },
+	{ "surround-51r", SPA_AUDIO_LAYOUT_5_1R },
+	{ "surround-70",  SPA_AUDIO_LAYOUT_7_0 },
+	{ "surround-71",  SPA_AUDIO_LAYOUT_7_1 },
+};
+
+static unsigned int find_channel(const char *name)
+{
+	int i;
+
+	for (i = 0; spa_type_audio_channel[i].name; i++) {
+		if (spa_streq(name, spa_debug_type_short_name(spa_type_audio_channel[i].name)))
+			return spa_type_audio_channel[i].type;
+	}
+	return SPA_AUDIO_CHANNEL_UNKNOWN;
+}
+
+static int parse_channelmap(const char *channel_map, struct channelmap *map)
+{
+	int i, nch;
+	char **ch;
+
+	SPA_FOR_EACH_ELEMENT_VAR(maps, m) {
+		if (spa_streq(m->name, channel_map)) {
+			map->n_channels = m->channels;
+			spa_memcpy(map->channels, &m->values,
+					map->n_channels * sizeof(unsigned int));
+			return 0;
+		}
+	}
+
+	ch = pw_split_strv(channel_map, ",", SPA_AUDIO_MAX_CHANNELS, &nch);
+	if (ch == NULL)
+		return -1;
+
+	map->n_channels = nch;
+	for (i = 0; i < map->n_channels; i++) {
+		int c = find_channel(ch[i]);
+		map->channels[i] = c;
+	}
+	pw_free_strv(ch);
+	return 0;
+}
+
+static int channelmap_default(struct channelmap *map, int n_channels)
+{
+	switch(n_channels) {
+	case 1:
+		parse_channelmap("mono", map);
+		break;
+	case 2:
+		parse_channelmap("stereo", map);
+		break;
+	case 3:
+		parse_channelmap("surround-21", map);
+		break;
+	case 4:
+		parse_channelmap("quad", map);
+		break;
+	case 5:
+		parse_channelmap("surround-50", map);
+		break;
+	case 6:
+		parse_channelmap("surround-51", map);
+		break;
+	case 7:
+		parse_channelmap("surround-70", map);
+		break;
+	case 8:
+		parse_channelmap("surround-71", map);
+		break;
+	default:
+		n_channels = 0;
+		break;
+	}
+	map->n_channels = n_channels;
+	return 0;
+}
+
+static void channelmap_print(struct channelmap *map)
+{
+	int i;
+
+	for (i = 0; i < map->n_channels; i++) {
+		const char *name = spa_debug_type_find_name(spa_type_audio_channel, map->channels[i]);
+		if (name == NULL)
+			name = ":UNK";
+		printf("%s%s", spa_debug_type_short_name(name), i + 1 < map->n_channels ? "," : "");
+	}
+}
+
+static void on_core_info(void *userdata, const struct pw_core_info *info)
+{
+	struct data *data = userdata;
+
+	if (data->verbose)
+		printf("remote %"PRIu32" is named \"%s\"\n",
+				info->id, info->name);
+}
+
+static void on_core_error(void *userdata, uint32_t id, int seq, int res, const char *message)
+{
+	struct data *data = userdata;
+
+	fprintf(stderr, "remote error: id=%"PRIu32" seq:%d res:%d (%s): %s\n",
+			id, seq, res, spa_strerror(res), message);
+
+	if (id == PW_ID_CORE && res == -EPIPE)
+		pw_main_loop_quit(data->loop);
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.info = on_core_info,
+	.error = on_core_error,
+};
+
+static void
+on_state_changed(void *userdata, enum pw_stream_state old,
+		 enum pw_stream_state state, const char *error)
+{
+	struct data *data = userdata;
+	int ret;
+
+	if (data->verbose)
+		printf("stream state changed %s -> %s\n",
+				pw_stream_state_as_string(old),
+				pw_stream_state_as_string(state));
+
+	switch (state) {
+	case PW_STREAM_STATE_STREAMING:
+		if (!data->volume_is_set) {
+			ret = pw_stream_set_control(data->stream,
+					SPA_PROP_volume, 1, &data->volume,
+					0);
+			if (data->verbose)
+				printf("stream set volume to %.3f - %s\n", data->volume,
+						ret == 0 ? "success" : "FAILED");
+
+			data->volume_is_set = true;
+		}
+		if (data->verbose) {
+			struct timespec timeout = {0, 1}, interval = {1, 0};
+			struct pw_loop *l = pw_main_loop_get_loop(data->loop);
+			pw_loop_update_timer(l, data->timer, &timeout, &interval, false);
+			printf("stream node %"PRIu32"\n",
+				pw_stream_get_node_id(data->stream));
+		}
+		break;
+	case PW_STREAM_STATE_PAUSED:
+		if (data->verbose) {
+			struct timespec timeout = {0, 0}, interval = {0, 0};
+			struct pw_loop *l = pw_main_loop_get_loop(data->loop);
+			pw_loop_update_timer(l, data->timer, &timeout, &interval, false);
+		}
+		break;
+	case PW_STREAM_STATE_ERROR:
+		printf("stream node %"PRIu32" error: %s\n",
+				pw_stream_get_node_id(data->stream),
+				error);
+		pw_main_loop_quit(data->loop);
+		break;
+	default:
+		break;
+	}
+}
+
+static void
+on_io_changed(void *userdata, uint32_t id, void *data, uint32_t size)
+{
+	struct data *d = userdata;
+
+	switch (id) {
+	case SPA_IO_Position:
+		d->position = data;
+		break;
+	default:
+		break;
+	}
+}
+
+static void
+on_param_changed(void *userdata, uint32_t id, const struct spa_pod *param)
+{
+	struct data *data = userdata;
+	struct spa_audio_info info = { 0 };
+	int err;
+
+	if (data->verbose)
+		printf("stream param change: %s\n",
+			spa_debug_type_find_name(spa_type_param, id));
+
+	if (id != SPA_PARAM_Format || param == NULL)
+		return;
+
+	if ((err = spa_format_parse(param, &info.media_type, &info.media_subtype)) < 0)
+		return;
+
+	if (info.media_type != SPA_MEDIA_TYPE_audio ||
+	    info.media_subtype != SPA_MEDIA_SUBTYPE_dsd)
+		return;
+
+	if (spa_format_audio_dsd_parse(param, &info.info.dsd) < 0)
+		return;
+
+	data->dsf.layout.interleave = info.info.dsd.interleave,
+	data->dsf.layout.channels = info.info.dsd.channels;
+	data->dsf.layout.lsb = info.info.dsd.bitorder == SPA_PARAM_BITORDER_lsb;
+
+	data->stride = data->dsf.layout.channels * SPA_ABS(data->dsf.layout.interleave);
+
+	if (data->verbose) {
+		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->stride);
+	}
+}
+
+static void on_process(void *userdata)
+{
+	struct data *data = userdata;
+	struct pw_buffer *b;
+	struct spa_buffer *buf;
+	struct spa_data *d;
+	int n_frames, n_fill_frames;
+	uint8_t *p;
+	bool have_data;
+	uint32_t offset, size;
+
+	if ((b = pw_stream_dequeue_buffer(data->stream)) == NULL)
+		return;
+
+	buf = b->buffer;
+	d = &buf->datas[0];
+
+	have_data = false;
+
+	if ((p = d->data) == NULL)
+		return;
+
+	if (data->mode == mode_playback) {
+		n_frames = d->maxsize / data->stride;
+		n_frames = SPA_MIN(n_frames, (int)b->requested);
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+		n_fill_frames = data->fill(data, p, n_frames);
+
+		if (n_fill_frames > 0 || n_frames == 0) {
+			d->chunk->offset = 0;
+			if (data->data_type == TYPE_ENCODED) {
+				d->chunk->stride = 0;
+				// encoded_playback_fill returns number of bytes
+				// read and not number of frames like other
+				// functions for raw audio.
+				d->chunk->size = n_fill_frames;
+				b->size = n_fill_frames;
+			} else {
+				d->chunk->stride = data->stride;
+				d->chunk->size = n_fill_frames * data->stride;
+				b->size = n_frames;
+			}
+			have_data = true;
+		} else if (n_fill_frames < 0) {
+			fprintf(stderr, "fill error %d\n", n_fill_frames);
+		} else {
+			if (data->verbose)
+				printf("drain start\n");
+		}
+#else
+		n_fill_frames = data->fill(data, p, n_frames);
+
+		if (n_fill_frames > 0 || n_frames == 0) {
+			d->chunk->offset = 0;
+			d->chunk->stride = data->stride;
+			d->chunk->size = n_fill_frames * data->stride;
+			have_data = true;
+			b->size = n_frames;
+		} else if (n_fill_frames < 0) {
+			fprintf(stderr, "fill error %d\n", n_fill_frames);
+		} else {
+			if (data->verbose)
+				printf("drain start\n");
+		}
+#endif
+	} else {
+		offset = SPA_MIN(d->chunk->offset, d->maxsize);
+		size = SPA_MIN(d->chunk->size, d->maxsize - offset);
+
+		p += offset;
+
+		n_frames = size / data->stride;
+
+		n_fill_frames = data->fill(data, p, n_frames);
+
+		have_data = true;
+	}
+
+	if (have_data) {
+		pw_stream_queue_buffer(data->stream, b);
+		return;
+	}
+
+	if (data->mode == mode_playback)
+		pw_stream_flush(data->stream, true);
+}
+
+static void on_drained(void *userdata)
+{
+	struct data *data = userdata;
+
+	if (data->verbose)
+		printf("stream drained\n");
+
+	data->drained = true;
+	pw_main_loop_quit(data->loop);
+}
+
+static const struct pw_stream_events stream_events = {
+	PW_VERSION_STREAM_EVENTS,
+	.state_changed = on_state_changed,
+	.io_changed = on_io_changed,
+	.param_changed = on_param_changed,
+	.process = on_process,
+	.drained = on_drained
+};
+
+static void do_quit(void *userdata, int signal_number)
+{
+	struct data *data = userdata;
+	pw_main_loop_quit(data->loop);
+}
+
+static void do_print_delay(void *userdata, uint64_t expirations)
+{
+	struct data *data = userdata;
+	struct pw_time time;
+	pw_stream_get_time_n(data->stream, &time, sizeof(time));
+	printf("stream time: now:%"PRIi64" rate:%u/%u ticks:%"PRIu64
+			" delay:%"PRIi64" queued:%"PRIu64
+			" buffered:%"PRIi64" buffers:%u avail:%u\n",
+		time.now,
+		time.rate.num, time.rate.denom,
+		time.ticks, time.delay, time.queued, time.buffered,
+		time.queued_buffers, time.avail_buffers);
+}
+
+enum {
+	OPT_VERSION = 1000,
+	OPT_MEDIA_TYPE,
+	OPT_MEDIA_CATEGORY,
+	OPT_MEDIA_ROLE,
+	OPT_TARGET,
+	OPT_LATENCY,
+	OPT_RATE,
+	OPT_CHANNELS,
+	OPT_CHANNELMAP,
+	OPT_FORMAT,
+	OPT_VOLUME,
+};
+
+static const struct option long_options[] = {
+	{ "help",		no_argument,	   NULL, 'h' },
+	{ "version",		no_argument,	   NULL, OPT_VERSION},
+	{ "verbose",		no_argument,	   NULL, 'v' },
+
+	{ "record",		no_argument,	   NULL, 'r' },
+	{ "playback",		no_argument,	   NULL, 'p' },
+	{ "midi",		no_argument,	   NULL, 'm' },
+
+	{ "remote",		required_argument, NULL, 'R' },
+
+	{ "media-type",		required_argument, NULL, OPT_MEDIA_TYPE },
+	{ "media-category",	required_argument, NULL, OPT_MEDIA_CATEGORY },
+	{ "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 },
+	{ "channel-map",	required_argument, NULL, OPT_CHANNELMAP },
+	{ "format",		required_argument, NULL, OPT_FORMAT },
+	{ "volume",		required_argument, NULL, OPT_VOLUME },
+	{ "quality",		required_argument, NULL, 'q' },
+
+	{ NULL, 0, NULL, 0 }
+};
+
+static void show_usage(const char *name, bool is_error)
+{
+	FILE *fp;
+
+	fp = is_error ? stderr : stdout;
+
+        fprintf(fp,
+	   _("%s [options] [<file>|-]\n"
+             "  -h, --help                            Show this help\n"
+             "      --version                         Show version\n"
+             "  -v, --verbose                         Enable verbose operations\n"
+	     "\n"), name);
+
+	fprintf(fp,
+           _("  -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 serial or name (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"
+	     "  -P  --properties                      Set node properties\n"
+	     "\n"),
+	     DEFAULT_MEDIA_TYPE,
+	     DEFAULT_MEDIA_CATEGORY_PLAYBACK,
+	     DEFAULT_MEDIA_ROLE,
+	     DEFAULT_TARGET, DEFAULT_LATENCY_PLAY);
+
+	fprintf(fp,
+           _("      --rate                            Sample rate (req. for rec) (default %u)\n"
+             "      --channels                        Number of channels (req. for rec) (default %u)\n"
+             "      --channel-map                     Channel map\n"
+	     "                                            one of: \"stereo\", \"surround-51\",... or\n"
+	     "                                            comma separated list of channel names: eg. \"FL,FR\"\n"
+             "      --format                          Sample format %s (req. for rec) (default %s)\n"
+	     "      --volume                          Stream volume 0-1.0 (default %.3f)\n"
+	     "  -q  --quality                         Resampler quality (0 - 15) (default %d)\n"
+	     "\n"),
+	     DEFAULT_RATE,
+	     DEFAULT_CHANNELS,
+	     STR_FMTS, DEFAULT_FORMAT,
+	     DEFAULT_VOLUME,
+	     DEFAULT_QUALITY);
+
+	if (spa_streq(name, "pw-cat")) {
+		fputs(
+		   _("  -p, --playback                        Playback mode\n"
+		     "  -r, --record                          Recording mode\n"
+		     "  -m, --midi                            Midi mode\n"
+		     "  -d, --dsd                             DSD mode\n"
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+		     "  -o, --encoded			      Encoded mode\n"
+#endif
+		     "\n"), fp);
+	}
+}
+
+static int midi_play(struct data *d, void *src, unsigned int n_frames)
+{
+	int res;
+	struct spa_pod_builder b;
+	struct spa_pod_frame f;
+	uint32_t first_frame, last_frame;
+	bool have_data = false;
+
+	spa_zero(b);
+	spa_pod_builder_init(&b, src, n_frames);
+
+        spa_pod_builder_push_sequence(&b, &f, 0);
+
+	first_frame = d->clock_time;
+	last_frame = first_frame + d->position->clock.duration;
+	d->clock_time = last_frame;
+
+	while (1) {
+		uint32_t frame;
+		struct midi_event ev;
+
+		res = midi_file_next_time(d->midi.file, &ev.sec);
+		if (res <= 0) {
+			if (have_data)
+				break;
+			return res;
+		}
+
+		frame = ev.sec * d->position->clock.rate.denom;
+		if (frame < first_frame)
+			frame = 0;
+		else if (frame < last_frame)
+			frame -= first_frame;
+		else
+			break;
+
+		midi_file_read_event(d->midi.file, &ev);
+
+		if (d->verbose)
+			midi_file_dump_event(stdout, &ev);
+
+		if (ev.data[0] == 0xff)
+			continue;
+
+		spa_pod_builder_control(&b, frame, SPA_CONTROL_Midi);
+		spa_pod_builder_bytes(&b, ev.data, ev.size);
+		have_data = true;
+	}
+	spa_pod_builder_pop(&b, &f);
+
+	return b.state.offset;
+}
+
+static int midi_record(struct data *d, void *src, unsigned int n_frames)
+{
+	struct spa_pod *pod;
+	struct spa_pod_control *c;
+	uint32_t frame;
+
+	frame = d->clock_time;
+	d->clock_time += d->position->clock.duration;
+
+	if ((pod = spa_pod_from_data(src, n_frames, 0, n_frames)) == NULL)
+		return 0;
+	if (!spa_pod_is_sequence(pod))
+		return 0;
+
+	SPA_POD_SEQUENCE_FOREACH((struct spa_pod_sequence*)pod, c) {
+		struct midi_event ev;
+
+		if (c->type != SPA_CONTROL_Midi)
+			continue;
+
+		ev.track = 0;
+		ev.sec = (frame + c->offset) / (float) d->position->clock.rate.denom;
+		ev.data = SPA_POD_BODY(&c->value),
+		ev.size = SPA_POD_BODY_SIZE(&c->value);
+
+		if (d->verbose)
+			midi_file_dump_event(stdout, &ev);
+
+		midi_file_write_event(d->midi.file, &ev);
+	}
+	return 0;
+}
+
+static int setup_midifile(struct data *data)
+{
+	if (data->mode == mode_record) {
+		spa_zero(data->midi.info);
+		data->midi.info.format = 0;
+		data->midi.info.ntracks = 1;
+		data->midi.info.division = 0;
+	}
+
+	data->midi.file = midi_file_open(data->filename,
+			data->mode == mode_playback ? "r" : "w",
+			&data->midi.info);
+	if (data->midi.file == NULL) {
+		fprintf(stderr, "midifile: can't read midi file '%s': %m\n", data->filename);
+		return -errno;
+	}
+
+	if (data->verbose)
+		printf("midifile: opened file \"%s\" format %08x ntracks:%d div:%d\n",
+				data->filename,
+				data->midi.info.format, data->midi.info.ntracks,
+				data->midi.info.division);
+
+	data->fill = data->mode == mode_playback ?  midi_play : midi_record;
+	data->stride = 1;
+
+	return 0;
+}
+
+struct dsd_layout_info {
+	 uint32_t type;
+	 struct spa_audio_layout_info info;
+};
+static const struct dsd_layout_info dsd_layouts[] = {
+	{ 1, { SPA_AUDIO_LAYOUT_Mono, }, },
+	{ 2, { SPA_AUDIO_LAYOUT_Stereo, }, },
+	{ 3, { SPA_AUDIO_LAYOUT_2FC }, },
+	{ 4, { SPA_AUDIO_LAYOUT_Quad }, },
+	{ 5, { SPA_AUDIO_LAYOUT_3_1 }, },
+	{ 6, { SPA_AUDIO_LAYOUT_5_0R }, },
+	{ 7, { SPA_AUDIO_LAYOUT_5_1R }, },
+};
+
+static int dsf_play(struct data *d, void *src, unsigned int n_frames)
+{
+	return dsf_file_read(d->dsf.file, src, n_frames, &d->dsf.layout);
+}
+
+static int setup_dsffile(struct data *data)
+{
+	if (data->mode == mode_record)
+		return -ENOTSUP;
+
+	data->dsf.file = dsf_file_open(data->filename, "r", &data->dsf.info);
+	if (data->dsf.file == NULL) {
+		fprintf(stderr, "dsffile: can't read dsf file '%s': %m\n", data->filename);
+		return -errno;
+	}
+
+	if (data->verbose)
+		printf("dsffile: opened file \"%s\" channels:%d rate:%d samples:%"PRIu64" bitorder:%s\n",
+				data->filename,
+				data->dsf.info.channels, data->dsf.info.rate,
+				data->dsf.info.samples,
+				data->dsf.info.lsb ? "lsb" : "msb");
+
+	data->fill = dsf_play;
+
+	return 0;
+}
+
+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)
+{
+	const 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;
+
+	if (data->verbose)
+		printf("PIPE: rate=%u channels=%u fmt=%s samplesize=%u stride=%u\n",
+				data->rate, data->channels,
+				info->name, info->width, data->stride);
+
+	return 0;
+}
+
+static int fill_properties(struct data *data)
+{
+	static const char * const table[] = {
+		[SF_STR_TITLE] = PW_KEY_MEDIA_TITLE,
+		[SF_STR_COPYRIGHT] = PW_KEY_MEDIA_COPYRIGHT,
+		[SF_STR_SOFTWARE] = PW_KEY_MEDIA_SOFTWARE,
+		[SF_STR_ARTIST] = PW_KEY_MEDIA_ARTIST,
+		[SF_STR_COMMENT] = PW_KEY_MEDIA_COMMENT,
+		[SF_STR_DATE] = PW_KEY_MEDIA_DATE
+	};
+
+	SF_INFO sfi;
+	SF_FORMAT_INFO fi;
+	int res;
+	unsigned c;
+	const char *s, *t;
+
+	for (c = 0; c < SPA_N_ELEMENTS(table); c++) {
+		if (table[c] == NULL)
+			continue;
+
+		if ((s = sf_get_string(data->file, c)) == NULL ||
+		    *s == '\0')
+			continue;
+
+		pw_properties_set(data->props, table[c], s);
+	}
+
+	spa_zero(sfi);
+	if ((res = sf_command(data->file, SFC_GET_CURRENT_SF_INFO, &sfi, sizeof(sfi)))) {
+		pw_log_error("sndfile: %s", sf_error_number(res));
+		return -EIO;
+	}
+
+	spa_zero(fi);
+	fi.format = sfi.format;
+	if (sf_command(data->file, SFC_GET_FORMAT_INFO, &fi, sizeof(fi)) == 0 && fi.name)
+		pw_properties_set(data->props, PW_KEY_MEDIA_FORMAT, fi.name);
+
+	s = pw_properties_get(data->props, PW_KEY_MEDIA_TITLE);
+	t = pw_properties_get(data->props, PW_KEY_MEDIA_ARTIST);
+	if (s && t)
+		pw_properties_setf(data->props, PW_KEY_MEDIA_NAME,
+				"'%s' / '%s'", s, t);
+
+	return 0;
+}
+static void format_from_filename(SF_INFO *info, const char *filename)
+{
+	int i, count = 0;
+	int format = -1;
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+	info->format |= SF_ENDIAN_BIG;
+#else
+	info->format |= SF_ENDIAN_LITTLE;
+#endif
+
+	if (sf_command(NULL, SFC_GET_FORMAT_MAJOR_COUNT, &count, sizeof(int)) != 0)
+		count = 0;
+
+	for (i = 0; i < count; i++) {
+		SF_FORMAT_INFO fi;
+
+		spa_zero(fi);
+		fi.format = i;
+		if (sf_command(NULL, SFC_GET_FORMAT_MAJOR, &fi, sizeof(fi)) != 0)
+			continue;
+
+		if (spa_strendswith(filename, fi.extension)) {
+			format = fi.format;
+			break;
+		}
+	}
+	if (format == -1)
+		format = SF_FORMAT_WAV;
+	if (format == SF_FORMAT_WAV && info->channels > 2)
+		format = SF_FORMAT_WAVEX;
+
+	info->format |= format;
+
+	if (format == SF_FORMAT_OGG || format == SF_FORMAT_FLAC)
+		info->format = (info->format & ~SF_FORMAT_ENDMASK) | SF_ENDIAN_FILE;
+	if (format == SF_FORMAT_OGG)
+		info->format = (info->format & ~SF_FORMAT_SUBMASK) | SF_FORMAT_VORBIS;
+}
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+static int setup_encodedfile(struct data *data)
+{
+	int ret;
+	int bits_per_sample;
+	int num_channels;
+	char path[256] = { 0 };
+
+	/* We do not support record with encoded media */
+	if (data->mode == mode_record) {
+		return -EINVAL;
+	}
+
+	strcpy(path, "file:");
+	strcat(path, data->filename);
+
+	data->fmt_context = NULL;
+	ret = avformat_open_input(&data->fmt_context, path, NULL, NULL);
+	if (ret < 0) {
+		fprintf(stderr, "Failed to open input\n");
+		return -EINVAL;
+	}
+
+	avformat_find_stream_info (data->fmt_context, NULL);
+
+	data->ctx = avcodec_alloc_context3(NULL);
+	if (!data->ctx) {
+		fprintf(stderr, "Could not allocate audio codec context\n");
+		avformat_close_input(&data->fmt_context);
+		return -EINVAL;
+	}
+
+	// We expect only one stream with audio
+	data->astream = data->fmt_context->streams[0];
+	avcodec_parameters_to_context (data->ctx, data->astream->codecpar);
+
+	if (data->ctx->codec_type != AVMEDIA_TYPE_AUDIO) {
+		fprintf(stderr, "Not an audio file\n");
+		avformat_close_input(&data->fmt_context);
+		return -EINVAL;
+	}
+
+	printf("Number of streams: %d Codec id: %x\n", data->fmt_context->nb_streams,
+			data->ctx->codec_id);
+
+	/* FFmpeg 5.1 (which contains libavcodec 59.37.100) introduced
+	 * a new channel layout API and deprecated the old one. */
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 37, 100)
+	num_channels = data->ctx->ch_layout.nb_channels;
+#else
+	num_channels = data->ctx->channels;
+#endif
+
+	data->rate = data->ctx->sample_rate;
+	data->channels = num_channels;
+	data->sfmt = data->ctx->sample_fmt;
+	data->stride = 1; // Don't care
+
+	bits_per_sample = av_get_bits_per_sample(data->ctx->codec_id);
+	data->bitrate = bits_per_sample ?
+		data->ctx->sample_rate * num_channels * bits_per_sample : data->ctx->bit_rate;
+
+	data->spa_format = SPA_AUDIO_FORMAT_ENCODED;
+	data->fill = playback_fill_fn(data->spa_format);
+
+	if (data->verbose)
+		printf("Opened file \"%s\" sample format %08x channels:%d rate:%d bitrate: %d\n",
+				data->filename, data->ctx->sample_fmt, data->channels,
+				data->rate, data->bitrate);
+
+	if (data->fill == NULL) {
+		fprintf(stderr, "Unhandled encoded format %d\n", data->spa_format);
+		avformat_close_input(&data->fmt_context);
+		return -EINVAL;
+	}
+
+	avformat_close_input(&data->fmt_context);
+
+	data->encoded_file = fopen(data->filename, "rb");
+	if (!data->encoded_file) {
+		fprintf(stderr, "Failed to open file\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+#endif
+
+static int setup_sndfile(struct data *data)
+{
+	const struct format_info *fi = NULL;
+	SF_INFO info;
+
+	spa_zero(info);
+	/* for record, you fill in the info first */
+	if (data->mode == mode_record) {
+		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);
+
+		if ((fi = format_info_by_name(data->format)) == NULL) {
+			fprintf(stderr, "error: unknown format \"%s\"\n", data->format);
+			return -EINVAL;
+		}
+		memset(&info, 0, sizeof(info));
+		info.samplerate = data->rate;
+		info.channels = data->channels;
+		info.format = fi->sf_format;
+		format_from_filename(&info, data->filename);
+	}
+
+	data->file = sf_open(data->filename,
+			data->mode == mode_playback ? SFM_READ : SFM_WRITE,
+			&info);
+	if (!data->file) {
+		fprintf(stderr, "sndfile: failed to open audio file \"%s\": %s\n",
+				data->filename, sf_strerror(NULL));
+		return -EIO;
+	}
+
+	if (data->verbose)
+		printf("sndfile: opened file \"%s\" format %08x channels:%d rate:%d\n",
+				data->filename, info.format, info.channels, info.samplerate);
+	if (data->channels > 0 && info.channels != data->channels) {
+		fprintf(stderr, "sndfile: given channels (%u) don't match file channels (%d)\n",
+				data->channels, info.channels);
+		return -EINVAL;
+	}
+
+	data->rate = info.samplerate;
+	data->channels = info.channels;
+
+	if (data->mode == mode_playback) {
+		if (data->channelmap.n_channels == 0) {
+			bool def = false;
+
+			if (sf_command(data->file, SFC_GET_CHANNEL_MAP_INFO,
+					data->channelmap.channels,
+					sizeof(data->channelmap.channels[0]) * data->channels)) {
+				data->channelmap.n_channels = data->channels;
+				if (channelmap_from_sf(&data->channelmap) < 0)
+					data->channelmap.n_channels = 0;
+			}
+			if (data->channelmap.n_channels == 0) {
+				channelmap_default(&data->channelmap, data->channels);
+				def = true;
+			}
+			if (data->verbose) {
+				printf("sndfile: using %s channel map: ", def ? "default" : "file");
+				channelmap_print(&data->channelmap);
+				printf("\n");
+			}
+		}
+		fill_properties(data);
+
+		/* try native format first, else decode to float */
+		if ((fi = format_info_by_sf_format(info.format)) == NULL)
+			fi = format_info_by_sf_format(SF_FORMAT_FLOAT);
+
+	}
+	if (fi == NULL)
+		return -EIO;
+
+	if (data->verbose)
+		printf("PCM: fmt:%s rate:%u channels:%u width:%u\n",
+				fi->name, data->rate, data->channels, fi->width);
+
+	/* we read and write S24 as S32 with sndfile */
+	if (fi->spa_format == SPA_AUDIO_FORMAT_S24)
+		fi = format_info_by_sf_format(SF_FORMAT_PCM_32);
+
+	data->spa_format = fi->spa_format;
+	data->stride = fi->width * data->channels;
+	data->fill = data->mode == mode_playback ?
+			playback_fill_fn(data->spa_format) :
+			record_fill_fn(data->spa_format);
+
+	if (data->fill == NULL) {
+		fprintf(stderr, "PCM: unhandled format %d\n", data->spa_format);
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int setup_properties(struct data *data)
+{
+	const char *s;
+	unsigned int nom = 0;
+
+	if (data->quality >= 0)
+		pw_properties_setf(data->props, "resample.quality", "%d", data->quality);
+
+	if (data->rate)
+		pw_properties_setf(data->props, PW_KEY_NODE_RATE, "1/%u", data->rate);
+
+	data->latency_unit = unit_none;
+
+	s = data->latency;
+	while (*s && isdigit(*s))
+		s++;
+	if (!*s)
+		data->latency_unit = unit_samples;
+	else if (spa_streq(s, "none"))
+		data->latency_unit = unit_none;
+	else if (spa_streq(s, "s") || spa_streq(s, "sec") || spa_streq(s, "secs"))
+		data->latency_unit = unit_sec;
+	else if (spa_streq(s, "ms") || spa_streq(s, "msec") || spa_streq(s, "msecs"))
+		data->latency_unit = unit_msec;
+	else if (spa_streq(s, "us") || spa_streq(s, "usec") || spa_streq(s, "usecs"))
+		data->latency_unit = unit_usec;
+	else if (spa_streq(s, "ns") || spa_streq(s, "nsec") || spa_streq(s, "nsecs"))
+		data->latency_unit = unit_nsec;
+	else {
+		fprintf(stderr, "error: bad latency value %s (bad unit)\n", data->latency);
+		return -EINVAL;
+	}
+	data->latency_value = atoi(data->latency);
+	if (!data->latency_value && data->latency_unit != unit_none) {
+		fprintf(stderr, "error: bad latency value %s (is zero)\n", data->latency);
+		return -EINVAL;
+	}
+
+	switch (data->latency_unit) {
+	case unit_sec:
+		nom = data->latency_value * data->rate;
+		break;
+	case unit_msec:
+		nom = nearbyint((data->latency_value * data->rate) / 1000.0);
+		break;
+	case unit_usec:
+		nom = nearbyint((data->latency_value * data->rate) / 1000000.0);
+		break;
+	case unit_nsec:
+		nom = nearbyint((data->latency_value * data->rate) / 1000000000.0);
+		break;
+	case unit_samples:
+		nom = data->latency_value;
+		break;
+	default:
+		nom = 0;
+		break;
+	}
+
+	if (data->verbose)
+		printf("rate:%d latency:%u (%.3fs)\n",
+				data->rate, nom, data->rate ? (double)nom/data->rate : 0.0f);
+	if (nom)
+		pw_properties_setf(data->props, PW_KEY_NODE_LATENCY, "%u/%u", nom, data->rate);
+
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0, };
+	struct pw_loop *l;
+	const struct spa_pod *params[1];
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+	const char *prog;
+	int exit_code = EXIT_FAILURE, c, ret;
+	enum pw_stream_flags flags = 0;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	flags |= PW_STREAM_FLAG_AUTOCONNECT;
+
+	prog = argv[0];
+	if ((prog = strrchr(argv[0], '/')) != NULL)
+		prog++;
+	else
+		prog = argv[0];
+
+	/* prime the mode from the program name */
+	if (spa_streq(prog, "pw-play")) {
+		data.mode = mode_playback;
+		data.data_type = TYPE_PCM;
+	} else if (spa_streq(prog, "pw-record")) {
+		data.mode = mode_record;
+		data.data_type = TYPE_PCM;
+	} else if (spa_streq(prog, "pw-midiplay")) {
+		data.mode = mode_playback;
+		data.data_type = TYPE_MIDI;
+	} else if (spa_streq(prog, "pw-midirecord")) {
+		data.mode = mode_record;
+		data.data_type = TYPE_MIDI;
+	} else if (spa_streq(prog, "pw-dsdplay")) {
+		data.mode = mode_playback;
+		data.data_type = TYPE_DSD;
+	} else
+		data.mode = mode_none;
+
+	/* 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);
+
+	if (data.props == NULL) {
+		fprintf(stderr, "error: pw_properties_new() failed: %m\n");
+		goto error_no_props;
+	}
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+	while ((c = getopt_long(argc, argv, "hvprmdoR:q:P:", long_options, NULL)) != -1) {
+#else
+	while ((c = getopt_long(argc, argv, "hvprmdR:q:P:", long_options, NULL)) != -1) {
+#endif
+
+		switch (c) {
+
+		case 'h':
+			show_usage(prog, false);
+			return EXIT_SUCCESS;
+
+		case OPT_VERSION:
+			printf("%s\n"
+				"Compiled with libpipewire %s\n"
+				"Linked with libpipewire %s\n",
+				prog,
+				pw_get_headers_version(),
+				pw_get_library_version());
+			return 0;
+
+		case 'v':
+			data.verbose = true;
+			break;
+
+		case 'p':
+			data.mode = mode_playback;
+			break;
+
+		case 'r':
+			data.mode = mode_record;
+			break;
+
+		case 'm':
+			data.data_type = TYPE_MIDI;
+			break;
+
+		case 'd':
+			data.data_type = TYPE_DSD;
+			break;
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+		case 'o':
+			data.data_type = TYPE_ENCODED;
+			break;
+#endif
+
+		case 'R':
+			data.remote_name = optarg;
+			break;
+
+		case 'q':
+			data.quality = atoi(optarg);
+			break;
+
+		case OPT_MEDIA_TYPE:
+			data.media_type = optarg;
+			break;
+
+		case OPT_MEDIA_CATEGORY:
+			data.media_category = optarg;
+			break;
+
+		case OPT_MEDIA_ROLE:
+			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")) {
+				data.target = NULL;
+				flags &= ~PW_STREAM_FLAG_AUTOCONNECT;
+			}
+			break;
+
+		case OPT_LATENCY:
+			data.latency = optarg;
+			break;
+
+		case OPT_RATE:
+			ret = atoi(optarg);
+			if (ret <= 0) {
+				fprintf(stderr, "error: bad rate %d\n", ret);
+				goto error_usage;
+			}
+			data.rate = (unsigned int)ret;
+			break;
+
+		case OPT_CHANNELS:
+			ret = atoi(optarg);
+			if (ret <= 0) {
+				fprintf(stderr, "error: bad channels %d\n", ret);
+				goto error_usage;
+			}
+			data.channels = (unsigned int)ret;
+			break;
+
+		case OPT_CHANNELMAP:
+			data.channel_map = optarg;
+			break;
+
+		case OPT_FORMAT:
+			data.format = optarg;
+			break;
+
+		case OPT_VOLUME:
+			data.volume = atof(optarg);
+			break;
+		default:
+			goto error_usage;
+		}
+	}
+
+	if (data.mode == mode_none) {
+		fprintf(stderr, "error: one of the playback/record options must be provided\n");
+		goto error_usage;
+	}
+
+	if (!data.media_type) {
+		switch (data.data_type) {
+		case TYPE_MIDI:
+			data.media_type = DEFAULT_MIDI_MEDIA_TYPE;
+			break;
+		default:
+			data.media_type = DEFAULT_MEDIA_TYPE;
+			break;
+		}
+	}
+	if (!data.media_category)
+		data.media_category = data.mode == mode_playback ?
+					DEFAULT_MEDIA_CATEGORY_PLAYBACK :
+					DEFAULT_MEDIA_CATEGORY_RECORD;
+	if (!data.media_role)
+		data.media_role = DEFAULT_MEDIA_ROLE;
+
+	if (!data.latency)
+		data.latency = data.mode == mode_playback ?
+			DEFAULT_LATENCY_PLAY :
+			DEFAULT_LATENCY_REC;
+	if (data.channel_map != NULL) {
+		if (parse_channelmap(data.channel_map, &data.channelmap) < 0) {
+			fprintf(stderr, "error: can parse channel-map \"%s\"\n", data.channel_map);
+			goto error_usage;
+
+		} else {
+			if (data.channels > 0 && data.channelmap.n_channels != data.channels) {
+				fprintf(stderr, "error: channels and channel-map incompatible\n");
+				goto error_usage;
+			}
+			data.channels = data.channelmap.n_channels;
+		}
+	}
+	if (data.volume < 0)
+		data.volume = DEFAULT_VOLUME;
+
+	if (optind >= argc) {
+		fprintf(stderr, "error: filename or - argument missing\n");
+		goto error_usage;
+	}
+	data.filename = argv[optind++];
+
+	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. */
+	data.loop = pw_main_loop_new(NULL);
+	if (!data.loop) {
+		fprintf(stderr, "error: pw_main_loop_new() failed: %m\n");
+		goto error_no_main_loop;
+	}
+
+	l = pw_main_loop_get_loop(data.loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data.context = pw_context_new(l,
+			pw_properties_new(
+				PW_KEY_CONFIG_NAME, "client-rt.conf",
+				NULL),
+			0);
+	if (!data.context) {
+		fprintf(stderr, "error: pw_context_new() failed: %m\n");
+		goto error_no_context;
+	}
+
+	data.core = pw_context_connect(data.context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, data.remote_name,
+				NULL),
+			0);
+	if (!data.core) {
+		fprintf(stderr, "error: pw_context_connect() failed: %m\n");
+		goto error_ctx_connect_failed;
+	}
+	pw_core_add_listener(data.core, &data.core_listener, &core_events, &data);
+
+	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;
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+		case TYPE_ENCODED:
+			ret = setup_encodedfile(&data);
+			break;
+#endif
+		default:
+			ret = -ENOTSUP;
+			break;
+		}
+	}
+	if (ret < 0) {
+		fprintf(stderr, "error: open failed: %s\n", spa_strerror(ret));
+		switch (ret) {
+		case -EIO:
+			goto error_bad_file;
+		case -EINVAL:
+		default:
+			goto error_usage;
+		}
+	}
+	ret = setup_properties(&data);
+
+	switch (data.data_type) {
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+	case TYPE_ENCODED:
+	{
+		struct spa_audio_info info;
+
+		spa_zero(info);
+		info.media_type = SPA_MEDIA_TYPE_audio;
+
+		ret = avcodec_ctx_to_info(&data, data.ctx, &info);
+		if (ret < 0) {
+			if (data.encoded_file) {
+				fclose(data.encoded_file);
+			}
+			goto error_bad_file;
+		}
+		params[0] = spa_format_audio_build(&b, SPA_PARAM_EnumFormat, &info);
+		break;
+	}
+#endif
+	case TYPE_PCM:
+	{
+		struct spa_audio_info_raw info;
+		info = SPA_AUDIO_INFO_RAW_INIT(
+			.flags = data.channelmap.n_channels ? 0 : SPA_AUDIO_FLAG_UNPOSITIONED,
+			.format = data.spa_format,
+			.rate = data.rate,
+			.channels = data.channels);
+
+		if (data.channelmap.n_channels)
+			memcpy(info.position, data.channelmap.channels, data.channels * sizeof(int));
+
+		params[0] = spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat, &info);
+		break;
+	}
+	case TYPE_MIDI:
+		params[0] = spa_pod_builder_add_object(&b,
+				SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
+				SPA_FORMAT_mediaType,		SPA_POD_Id(SPA_MEDIA_TYPE_application),
+				SPA_FORMAT_mediaSubtype,	SPA_POD_Id(SPA_MEDIA_SUBTYPE_control));
+
+		pw_properties_set(data.props, PW_KEY_FORMAT_DSP, "8 bit raw midi");
+		break;
+	case TYPE_DSD:
+	{
+		struct spa_audio_info_dsd info;
+
+		spa_zero(info);
+		info.channels = data.dsf.info.channels;
+		info.rate = data.dsf.info.rate / 8;
+
+		SPA_FOR_EACH_ELEMENT_VAR(dsd_layouts, i) {
+			if (i->type != data.dsf.info.channel_type)
+				continue;
+			info.channels = i->info.n_channels;
+			memcpy(info.position, i->info.position,
+					info.channels * sizeof(uint32_t));
+		}
+		params[0] = spa_format_audio_dsd_build(&b, SPA_PARAM_EnumFormat, &info);
+		break;
+	}
+	}
+
+	data.stream = pw_stream_new(data.core, prog, data.props);
+	data.props = NULL;
+
+	if (data.stream == NULL) {
+		fprintf(stderr, "error: failed to create stream: %m\n");
+		goto error_no_stream;
+	}
+	pw_stream_add_listener(data.stream, &data.stream_listener, &stream_events, &data);
+
+	if (data.verbose)
+		printf("connecting %s stream; target=%s\n",
+				data.mode == mode_playback ? "playback" : "record",
+				data.target);
+
+	if (data.verbose)
+		data.timer = pw_loop_add_timer(l, do_print_delay, &data);
+
+	ret = pw_stream_connect(data.stream,
+			  data.mode == mode_playback ? PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT,
+			  PW_ID_ANY,
+			  flags |
+			  PW_STREAM_FLAG_MAP_BUFFERS,
+			  params, 1);
+	if (ret < 0) {
+		fprintf(stderr, "error: failed connect: %s\n", spa_strerror(ret));
+		goto error_connect_fail;
+	}
+
+	if (data.verbose) {
+		const struct pw_properties *props;
+		void *pstate;
+		const char *key, *val;
+
+		if ((props = pw_stream_get_properties(data.stream)) != NULL) {
+			printf("stream properties:\n");
+			pstate = NULL;
+			while ((key = pw_properties_iterate(props, &pstate)) != NULL &&
+				(val = pw_properties_get(props, key)) != NULL) {
+				printf("\t%s = \"%s\"\n", key, val);
+			}
+		}
+	}
+
+	/* and wait while we let things run */
+	pw_main_loop_run(data.loop);
+
+#ifdef HAVE_PW_CAT_FFMPEG_INTEGRATION
+	if (data.encoded_file)
+		fclose(data.encoded_file);
+#endif
+
+	/* we're returning OK only if got to the point to drain */
+	if (data.drained)
+		exit_code = EXIT_SUCCESS;
+
+error_connect_fail:
+	if (data.stream) {
+		spa_hook_remove(&data.stream_listener);
+		pw_stream_destroy(data.stream);
+	}
+error_no_stream:
+error_bad_file:
+	spa_hook_remove(&data.core_listener);
+	pw_core_disconnect(data.core);
+error_ctx_connect_failed:
+	pw_context_destroy(data.context);
+error_no_context:
+	pw_main_loop_destroy(data.loop);
+error_no_props:
+error_no_main_loop:
+	pw_properties_free(data.props);
+	if (data.file)
+		sf_close(data.file);
+	if (data.midi.file)
+		midi_file_close(data.midi.file);
+	pw_deinit();
+	return exit_code;
+
+error_usage:
+	show_usage(prog, true);
+	return EXIT_FAILURE;
+}
diff --git a/src/tools/pw-cli.c b/src/tools/pw-cli.c
new file mode 100644
index 0000000..53a3384
--- /dev/null
+++ b/src/tools/pw-cli.c
@@ -0,0 +1,2375 @@
+/* PipeWire
+ *
+ * Copyright © 2018 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 "config.h"
+
+#include <unistd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <ctype.h>
+#if !defined(__FreeBSD__) && !defined(__MidnightBSD__)
+#include <alloca.h>
+#endif
+#include <getopt.h>
+#include <fnmatch.h>
+#ifdef HAVE_READLINE
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+#include <locale.h>
+
+#if !defined(FNM_EXTMATCH)
+#define FNM_EXTMATCH 0
+#endif
+
+#define spa_debug(fmt,...) printf(fmt"\n", ## __VA_ARGS__)
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/debug/pod.h>
+#include <spa/utils/keys.h>
+#include <spa/utils/json-pod.h>
+#include <spa/pod/builder.h>
+
+#include <pipewire/impl.h>
+#include <pipewire/i18n.h>
+
+#include <pipewire/extensions/session-manager.h>
+
+static const char WHITESPACE[] = " \t";
+static char prompt[64];
+
+struct remote_data;
+struct proxy_data;
+
+typedef void (*info_func_t) (struct proxy_data *pd);
+
+struct class {
+	const char *type;
+	uint32_t version;
+	const void *events;
+	pw_destroy_t destroy;
+	info_func_t info;
+	const char *name_key;
+};
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	struct spa_list remotes;
+	struct remote_data *current;
+
+	struct pw_map vars;
+	unsigned int interactive:1;
+	unsigned int monitoring:1;
+	unsigned int quit:1;
+};
+
+struct global {
+	struct remote_data *rd;
+	uint32_t id;
+	uint32_t permissions;
+	uint32_t version;
+	char *type;
+	const struct class *class;
+	struct pw_proxy *proxy;
+	bool info_pending;
+	struct pw_properties *properties;
+};
+
+struct remote_data {
+	struct spa_list link;
+	struct data *data;
+
+	char *name;
+	uint32_t id;
+
+	int prompt_pending;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+	struct spa_hook proxy_core_listener;
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct pw_map globals;
+};
+
+
+struct proxy_data {
+	struct remote_data *rd;
+	struct global *global;
+	struct pw_proxy *proxy;
+	void *info;
+	const struct class *class;
+	struct spa_hook proxy_listener;
+	struct spa_hook object_listener;
+};
+
+struct command {
+	const char *name;
+	const char *alias;
+	const char *description;
+	bool (*func) (struct data *data, const char *cmd, char *args, char **error);
+};
+
+static struct spa_dict * global_props(struct global *global);
+static struct global * obj_global(struct remote_data *rd, uint32_t id);
+static int children_of(struct remote_data *rd, uint32_t parent_id,
+	const char *child_type, uint32_t **children);
+
+static void print_properties(struct spa_dict *props, char mark, bool header)
+{
+	const struct spa_dict_item *item;
+
+	if (header)
+		printf("%c\tproperties:\n", mark);
+	if (props == NULL || props->n_items == 0) {
+		if (header)
+			printf("\t\tnone\n");
+		return;
+	}
+
+	spa_dict_for_each(item, props) {
+		printf("%c\t\t%s = \"%s\"\n", mark, item->key, item->value);
+	}
+}
+
+static void print_params(struct spa_param_info *params, uint32_t n_params, char mark, bool header)
+{
+	uint32_t i;
+
+	if (header)
+		printf("%c\tparams: (%u)\n", mark, n_params);
+	if (params == NULL || n_params == 0) {
+		if (header)
+			printf("\t\tnone\n");
+		return;
+	}
+	for (i = 0; i < n_params; i++) {
+		const struct spa_type_info *type_info = spa_type_param;
+
+		printf("%c\t  %d (%s) %c%c\n",
+				params[i].user > 0 ? mark : ' ', params[i].id,
+				spa_debug_type_find_name(type_info, params[i].id),
+				params[i].flags & SPA_PARAM_INFO_READ ? 'r' : '-',
+				params[i].flags & SPA_PARAM_INFO_WRITE ? 'w' : '-');
+		params[i].user = 0;
+	}
+}
+
+static bool do_not_implemented(struct data *data, const char *cmd, char *args, char **error)
+{
+        *error = spa_aprintf("Command \"%s\" not yet implemented", cmd);
+	return false;
+}
+
+static bool do_help(struct data *data, const char *cmd, char *args, char **error);
+static bool do_load_module(struct data *data, const char *cmd, char *args, char **error);
+static bool do_list_objects(struct data *data, const char *cmd, char *args, char **error);
+static bool do_connect(struct data *data, const char *cmd, char *args, char **error);
+static bool do_disconnect(struct data *data, const char *cmd, char *args, char **error);
+static bool do_list_remotes(struct data *data, const char *cmd, char *args, char **error);
+static bool do_switch_remote(struct data *data, const char *cmd, char *args, char **error);
+static bool do_info(struct data *data, const char *cmd, char *args, char **error);
+static bool do_create_device(struct data *data, const char *cmd, char *args, char **error);
+static bool do_create_node(struct data *data, const char *cmd, char *args, char **error);
+static bool do_destroy(struct data *data, const char *cmd, char *args, char **error);
+static bool do_create_link(struct data *data, const char *cmd, char *args, char **error);
+static bool do_export_node(struct data *data, const char *cmd, char *args, char **error);
+static bool do_enum_params(struct data *data, const char *cmd, char *args, char **error);
+static bool do_set_param(struct data *data, const char *cmd, char *args, char **error);
+static bool do_permissions(struct data *data, const char *cmd, char *args, char **error);
+static bool do_get_permissions(struct data *data, const char *cmd, char *args, char **error);
+static bool do_send_command(struct data *data, const char *cmd, char *args, char **error);
+static bool do_quit(struct data *data, const char *cmd, char *args, char **error);
+
+#define DUMP_NAMES "Core|Module|Device|Node|Port|Factory|Client|Link|Session|Endpoint|EndpointStream"
+
+static const struct command command_list[] = {
+	{ "help", "h", "Show this help", do_help },
+	{ "load-module", "lm", "Load a module. <module-name> [<module-arguments>]", do_load_module },
+	{ "unload-module", "um", "Unload a module. <module-var>", do_not_implemented },
+	{ "connect", "con", "Connect to a remote. [<remote-name>]", do_connect },
+	{ "disconnect", "dis", "Disconnect from a remote. [<remote-var>]", do_disconnect },
+	{ "list-remotes", "lr", "List connected remotes.", do_list_remotes },
+	{ "switch-remote", "sr", "Switch between current remotes. [<remote-var>]", do_switch_remote },
+	{ "list-objects", "ls", "List objects or current remote. [<interface>]", do_list_objects },
+	{ "info", "i", "Get info about an object. <object-id>|all", do_info },
+	{ "create-device", "cd", "Create a device from a factory. <factory-name> [<properties>]", do_create_device },
+	{ "create-node", "cn", "Create a node from a factory. <factory-name> [<properties>]", do_create_node },
+	{ "destroy", "d", "Destroy a global object. <object-id>", do_destroy },
+	{ "create-link", "cl", "Create a link between nodes. <node-id> <port-id> <node-id> <port-id> [<properties>]", do_create_link },
+	{ "export-node", "en", "Export a local node to the current remote. <node-id> [remote-var]", do_export_node },
+	{ "enum-params", "e", "Enumerate params of an object <object-id> <param-id>", do_enum_params },
+	{ "set-param", "s", "Set param of an object <object-id> <param-id> <param-json>", do_set_param },
+	{ "permissions", "sp", "Set permissions for a client <client-id> <object> <permission>", do_permissions },
+	{ "get-permissions", "gp", "Get permissions of a client <client-id>", do_get_permissions },
+	{ "send-command", "c", "Send a command <object-id>", do_send_command },
+	{ "quit", "q", "Quit", do_quit },
+};
+
+static bool do_quit(struct data *data, const char *cmd, char *args, char **error)
+{
+	pw_main_loop_quit(data->loop);
+	data->quit = true;
+	return true;
+}
+
+static bool do_help(struct data *data, const char *cmd, char *args, char **error)
+{
+	printf("Available commands:\n");
+	SPA_FOR_EACH_ELEMENT_VAR(command_list, c) {
+		char cmd[256];
+		snprintf(cmd, sizeof(cmd), "%s | %s", c->name, c->alias);
+		printf("\t%-20.20s\t%s\n", cmd, c->description);
+	}
+	return true;
+}
+
+static bool do_load_module(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct pw_impl_module *module;
+	char *a[2];
+	int n;
+	uint32_t id;
+
+	n = pw_split_ip(args, WHITESPACE, 2, a);
+	if (n < 1) {
+		*error = spa_aprintf("%s <module-name> [<module-arguments>]", cmd);
+		return false;
+	}
+
+	module = pw_context_load_module(data->context, a[0], n == 2 ? a[1] : NULL, NULL);
+	if (module == NULL) {
+		*error = spa_aprintf("Could not load module");
+		return false;
+	}
+
+	id = pw_map_insert_new(&data->vars, module);
+	if (data->interactive)
+		printf("%d = @module:%d\n", id, pw_global_get_id(pw_impl_module_get_global(module)));
+
+	return true;
+}
+
+static void on_core_info(void *_data, const struct pw_core_info *info)
+{
+	struct remote_data *rd = _data;
+	free(rd->name);
+	rd->name = info->name ? strdup(info->name) : NULL;
+	if (rd->data->interactive)
+		printf("remote %d is named '%s'\n", rd->id, rd->name);
+}
+
+static void set_prompt(struct remote_data *rd)
+{
+	snprintf(prompt, sizeof(prompt), "%s>> ", rd->name);
+#ifdef HAVE_READLINE
+	rl_set_prompt(prompt);
+#else
+	printf("%s", prompt);
+	fflush(stdout);
+#endif
+}
+
+static void on_core_done(void *_data, uint32_t id, int seq)
+{
+	struct remote_data *rd = _data;
+	struct data *d = rd->data;
+
+	if (seq == rd->prompt_pending) {
+		if (d->interactive) {
+			set_prompt(rd);
+			rd->data->monitoring = true;
+		} else {
+			pw_main_loop_quit(d->loop);
+		}
+	}
+}
+
+static bool global_matches(struct global *g, const char *pattern)
+{
+	const char *str;
+
+	if (g->properties == NULL)
+		return false;
+
+	if (strstr(g->type, pattern) != NULL)
+		return true;
+	if ((str = pw_properties_get(g->properties, PW_KEY_OBJECT_PATH)) != NULL &&
+	    fnmatch(pattern, str, FNM_EXTMATCH) == 0)
+		return true;
+	if ((str = pw_properties_get(g->properties, PW_KEY_OBJECT_SERIAL)) != NULL &&
+	    spa_streq(pattern, str))
+		return true;
+	if (g->class != NULL && g->class->name_key != NULL &&
+	    (str = pw_properties_get(g->properties, g->class->name_key)) != NULL &&
+	    fnmatch(pattern, str, FNM_EXTMATCH) == 0)
+		return true;
+
+	return false;
+}
+
+static int print_global(void *obj, void *data)
+{
+	struct global *global = obj;
+	const char *filter = data;
+
+	if (global == NULL)
+		return 0;
+
+	if (filter && !global_matches(global, filter))
+		return 0;
+
+	printf("\tid %d, type %s/%d\n", global->id,
+					global->type, global->version);
+	if (global->properties)
+		print_properties(&global->properties->dict, ' ', false);
+
+	return 0;
+}
+
+
+static bool bind_global(struct remote_data *rd, struct global *global, char **error);
+
+static void registry_event_global(void *data, uint32_t id,
+		uint32_t permissions, const char *type, uint32_t version,
+		const struct spa_dict *props)
+{
+	struct remote_data *rd = data;
+	struct global *global;
+	size_t size;
+	char *error;
+	bool ret;
+
+	global = calloc(1, sizeof(struct global));
+	global->rd = rd;
+	global->id = id;
+	global->permissions = permissions;
+	global->type = strdup(type);
+	global->version = version;
+	global->properties = props ? pw_properties_new_dict(props) : NULL;
+
+	if (rd->data->monitoring) {
+		printf("remote %d added global: ", rd->id);
+		print_global(global, NULL);
+	}
+
+	size = pw_map_get_size(&rd->globals);
+	while (id > size)
+		pw_map_insert_at(&rd->globals, size++, NULL);
+	pw_map_insert_at(&rd->globals, id, global);
+
+	/* immediately bind the object always */
+	ret = bind_global(rd, global, &error);
+	if (!ret) {
+		if (rd->data->interactive)
+			fprintf(stderr, "Error: \"%s\"\n", error);
+		free(error);
+	}
+}
+
+static int destroy_global(void *obj, void *data)
+{
+	struct global *global = obj;
+
+	if (global == NULL)
+		return 0;
+
+	if (global->proxy)
+		pw_proxy_destroy(global->proxy);
+	pw_map_insert_at(&global->rd->globals, global->id, NULL);
+	pw_properties_free(global->properties);
+	free(global->type);
+	free(global);
+	return 0;
+}
+
+static void registry_event_global_remove(void *data, uint32_t id)
+{
+	struct remote_data *rd = data;
+	struct global *global;
+
+	global = pw_map_lookup(&rd->globals, id);
+	if (global == NULL) {
+		fprintf(stderr, "remote %d removed unknown global %d\n", rd->id, id);
+		return;
+	}
+
+	if (rd->data->monitoring) {
+		printf("remote %d removed global: ", rd->id);
+		print_global(global, NULL);
+	}
+
+	destroy_global(global, rd);
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+	.global_remove = registry_event_global_remove,
+};
+
+static struct global *find_global(struct remote_data *rd, const char *pattern)
+{
+	uint32_t id;
+	union pw_map_item *item;
+
+	if (spa_atou32(pattern, &id, 0))
+		return pw_map_lookup(&rd->globals, id);
+
+	pw_array_for_each(item, &rd->globals.items) {
+		struct global *g = item->data;
+		if (pw_map_item_is_free(item) || g == NULL)
+			continue;
+		if (global_matches(g, pattern))
+			return g;
+        }
+	return NULL;
+}
+
+static void on_core_error(void *_data, uint32_t id, int seq, int res, const char *message)
+{
+	struct remote_data *rd = _data;
+	struct data *data = rd->data;
+
+	pw_log_error("remote %p: error id:%u seq:%d res:%d (%s): %s", rd,
+			id, seq, res, spa_strerror(res), message);
+
+	if (id == PW_ID_CORE && res == -EPIPE)
+		pw_main_loop_quit(data->loop);
+}
+
+static const struct pw_core_events remote_core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.info = on_core_info,
+	.done = on_core_done,
+	.error = on_core_error,
+};
+
+static void on_core_destroy(void *_data)
+{
+	struct remote_data *rd = _data;
+	struct data *data = rd->data;
+
+	spa_list_remove(&rd->link);
+
+	spa_hook_remove(&rd->core_listener);
+	spa_hook_remove(&rd->proxy_core_listener);
+
+	pw_map_remove(&data->vars, rd->id);
+	pw_map_for_each(&rd->globals, destroy_global, rd);
+	pw_map_clear(&rd->globals);
+
+	if (data->current == rd)
+		data->current = NULL;
+	free(rd->name);
+}
+
+static const struct pw_proxy_events proxy_core_events = {
+	PW_VERSION_PROXY_EVENTS,
+	.destroy = on_core_destroy,
+};
+
+static void remote_data_free(struct remote_data *rd)
+{
+	spa_hook_remove(&rd->registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)rd->registry);
+	pw_core_disconnect(rd->core);
+}
+
+static bool do_connect(struct data *data, const char *cmd, char *args, char **error)
+{
+	char *a[1];
+        int n;
+	struct pw_properties *props = NULL;
+	struct pw_core *core;
+	struct remote_data *rd;
+
+	n = args ? pw_split_ip(args, WHITESPACE, 1, a) : 0;
+	if (n == 1) {
+		props = pw_properties_new(PW_KEY_REMOTE_NAME, a[0], NULL);
+	}
+	core = pw_context_connect(data->context, props, sizeof(struct remote_data));
+	if (core == NULL) {
+		*error = spa_aprintf("failed to connect: %m");
+		return false;
+	}
+
+	rd = pw_proxy_get_user_data((struct pw_proxy*)core);
+	rd->core = core;
+	rd->data = data;
+	pw_map_init(&rd->globals, 64, 16);
+	rd->id = pw_map_insert_new(&data->vars, rd);
+	spa_list_append(&data->remotes, &rd->link);
+
+	if (rd->data->interactive)
+		printf("%d = @remote:%p\n", rd->id, rd->core);
+
+	data->current = rd;
+
+	pw_core_add_listener(rd->core,
+				   &rd->core_listener,
+				   &remote_core_events, rd);
+	pw_proxy_add_listener((struct pw_proxy*)rd->core,
+			&rd->proxy_core_listener,
+			&proxy_core_events, rd);
+	rd->registry = pw_core_get_registry(rd->core, PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(rd->registry,
+				       &rd->registry_listener,
+				       &registry_events, rd);
+	rd->prompt_pending = pw_core_sync(rd->core, 0, 0);
+
+	return true;
+}
+
+static bool do_disconnect(struct data *data, const char *cmd, char *args, char **error)
+{
+	char *a[1];
+        int n;
+	uint32_t idx;
+	struct remote_data *rd = data->current;
+
+	n = pw_split_ip(args, WHITESPACE, 1, a);
+	if (n >= 1) {
+		idx = atoi(a[0]);
+		rd = pw_map_lookup(&data->vars, idx);
+		if (rd == NULL)
+			goto no_remote;
+
+	}
+	if (rd)
+		remote_data_free(rd);
+
+	if (data->current == NULL) {
+		if (spa_list_is_empty(&data->remotes)) {
+			return true;
+		}
+		data->current = spa_list_last(&data->remotes, struct remote_data, link);
+	}
+
+	return true;
+
+      no_remote:
+        *error = spa_aprintf("Remote %d does not exist", idx);
+	return false;
+}
+
+static bool do_list_remotes(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd;
+
+	spa_list_for_each(rd, &data->remotes, link)
+		printf("\t%d = @remote:%p '%s'\n", rd->id, rd->core, rd->name);
+
+	return true;
+}
+
+static bool do_switch_remote(struct data *data, const char *cmd, char *args, char **error)
+{
+	char *a[1];
+        int n, idx = 0;
+	struct remote_data *rd;
+
+	n = pw_split_ip(args, WHITESPACE, 1, a);
+	if (n == 1)
+		idx = atoi(a[0]);
+
+	rd = pw_map_lookup(&data->vars, idx);
+	if (rd == NULL)
+		goto no_remote;
+
+	spa_list_remove(&rd->link);
+	spa_list_append(&data->remotes, &rd->link);
+	data->current = rd;
+
+	return true;
+
+      no_remote:
+        *error = spa_aprintf("Remote %d does not exist", idx);
+	return false;
+}
+
+#define MARK_CHANGE(f) ((((info)->change_mask & (f))) ? '*' : ' ')
+
+static void info_global(struct proxy_data *pd)
+{
+	struct global *global = pd->global;
+
+	if (global == NULL)
+		return;
+
+	printf("\tid: %d\n", global->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(global->permissions));
+	printf("\ttype: %s/%d\n", global->type, global->version);
+}
+
+static void info_core(struct proxy_data *pd)
+{
+	struct pw_core_info *info = pd->info;
+
+	info_global(pd);
+	printf("\tcookie: %u\n", info->cookie);
+	printf("\tuser-name: \"%s\"\n", info->user_name);
+	printf("\thost-name: \"%s\"\n", info->host_name);
+	printf("\tversion: \"%s\"\n", info->version);
+	printf("\tname: \"%s\"\n", info->name);
+	print_properties(info->props, MARK_CHANGE(PW_CORE_CHANGE_MASK_PROPS), true);
+	info->change_mask = 0;
+}
+
+static void info_module(struct proxy_data *pd)
+{
+	struct pw_module_info *info = pd->info;
+
+	info_global(pd);
+	printf("\tname: \"%s\"\n", info->name);
+	printf("\tfilename: \"%s\"\n", info->filename);
+	printf("\targs: \"%s\"\n", info->args);
+	print_properties(info->props, MARK_CHANGE(PW_MODULE_CHANGE_MASK_PROPS), true);
+	info->change_mask = 0;
+}
+
+static void info_node(struct proxy_data *pd)
+{
+	struct pw_node_info *info = pd->info;
+
+	info_global(pd);
+	printf("%c\tinput ports: %u/%u\n", MARK_CHANGE(PW_NODE_CHANGE_MASK_INPUT_PORTS),
+			info->n_input_ports, info->max_input_ports);
+	printf("%c\toutput ports: %u/%u\n", MARK_CHANGE(PW_NODE_CHANGE_MASK_OUTPUT_PORTS),
+			info->n_output_ports, info->max_output_ports);
+	printf("%c\tstate: \"%s\"", MARK_CHANGE(PW_NODE_CHANGE_MASK_STATE),
+			pw_node_state_as_string(info->state));
+	if (info->state == PW_NODE_STATE_ERROR && info->error)
+		printf(" \"%s\"\n", info->error);
+	else
+		printf("\n");
+	print_properties(info->props, MARK_CHANGE(PW_NODE_CHANGE_MASK_PROPS), true);
+	print_params(info->params, info->n_params, MARK_CHANGE(PW_NODE_CHANGE_MASK_PARAMS), true);
+	info->change_mask = 0;
+}
+
+static void info_port(struct proxy_data *pd)
+{
+	struct pw_port_info *info = pd->info;
+
+	info_global(pd);
+	printf("\tdirection: \"%s\"\n", pw_direction_as_string(info->direction));
+	print_properties(info->props, MARK_CHANGE(PW_PORT_CHANGE_MASK_PROPS), true);
+	print_params(info->params, info->n_params, MARK_CHANGE(PW_PORT_CHANGE_MASK_PARAMS), true);
+	info->change_mask = 0;
+}
+
+static void info_factory(struct proxy_data *pd)
+{
+	struct pw_factory_info *info = pd->info;
+
+	info_global(pd);
+	printf("\tname: \"%s\"\n", info->name);
+	printf("\tobject-type: %s/%d\n", info->type, info->version);
+	print_properties(info->props, MARK_CHANGE(PW_FACTORY_CHANGE_MASK_PROPS), true);
+	info->change_mask = 0;
+}
+
+static void info_client(struct proxy_data *pd)
+{
+	struct pw_client_info *info = pd->info;
+
+	info_global(pd);
+	print_properties(info->props, MARK_CHANGE(PW_CLIENT_CHANGE_MASK_PROPS), true);
+	info->change_mask = 0;
+}
+
+static void info_link(struct proxy_data *pd)
+{
+	struct pw_link_info *info = pd->info;
+
+	info_global(pd);
+	printf("\toutput-node-id: %u\n", info->output_node_id);
+	printf("\toutput-port-id: %u\n", info->output_port_id);
+	printf("\tinput-node-id: %u\n", info->input_node_id);
+	printf("\tinput-port-id: %u\n", info->input_port_id);
+
+	printf("%c\tstate: \"%s\"", MARK_CHANGE(PW_LINK_CHANGE_MASK_STATE),
+			pw_link_state_as_string(info->state));
+	if (info->state == PW_LINK_STATE_ERROR && info->error)
+		printf(" \"%s\"\n", info->error);
+	else
+		printf("\n");
+	printf("%c\tformat:\n", MARK_CHANGE(PW_LINK_CHANGE_MASK_FORMAT));
+	if (info->format)
+		spa_debug_pod(2, NULL, info->format);
+	else
+		printf("\t\tnone\n");
+	print_properties(info->props, MARK_CHANGE(PW_LINK_CHANGE_MASK_PROPS), true);
+	info->change_mask = 0;
+}
+
+static void info_device(struct proxy_data *pd)
+{
+	struct pw_device_info *info = pd->info;
+
+	info_global(pd);
+	print_properties(info->props, MARK_CHANGE(PW_DEVICE_CHANGE_MASK_PROPS), true);
+	print_params(info->params, info->n_params, MARK_CHANGE(PW_DEVICE_CHANGE_MASK_PARAMS), true);
+	info->change_mask = 0;
+}
+
+static void info_session(struct proxy_data *pd)
+{
+	struct pw_session_info *info = pd->info;
+
+	info_global(pd);
+	print_properties(info->props, MARK_CHANGE(0), true);
+	print_params(info->params, info->n_params, MARK_CHANGE(1), true);
+	info->change_mask = 0;
+}
+
+static void info_endpoint(struct proxy_data *pd)
+{
+	struct pw_endpoint_info *info = pd->info;
+	const char *direction;
+
+	info_global(pd);
+	printf("\tname: %s\n", info->name);
+	printf("\tmedia-class: %s\n",  info->media_class);
+	switch(info->direction) {
+	case PW_DIRECTION_OUTPUT:
+		direction = "source";
+		break;
+	case PW_DIRECTION_INPUT:
+		direction = "sink";
+		break;
+	default:
+		direction = "invalid";
+		break;
+	}
+	printf("\tdirection: %s\n", direction);
+	printf("\tflags: 0x%x\n", info->flags);
+	printf("%c\tstreams: %u\n", MARK_CHANGE(0), info->n_streams);
+	printf("%c\tsession: %u\n", MARK_CHANGE(1), info->session_id);
+	print_properties(info->props, MARK_CHANGE(2), true);
+	print_params(info->params, info->n_params, MARK_CHANGE(3), true);
+	info->change_mask = 0;
+}
+
+static void info_endpoint_stream(struct proxy_data *pd)
+{
+	struct pw_endpoint_stream_info *info = pd->info;
+
+	info_global(pd);
+	printf("\tid: %u\n", info->id);
+	printf("\tendpoint-id: %u\n", info->endpoint_id);
+	printf("\tname: %s\n", info->name);
+	print_properties(info->props, MARK_CHANGE(1), true);
+	print_params(info->params, info->n_params, MARK_CHANGE(2), true);
+	info->change_mask = 0;
+}
+
+static void core_event_info(void *data, const struct pw_core_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d core %d changed\n", rd->id, info->id);
+	pd->info = pw_core_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_core(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.info = core_event_info
+};
+
+
+static void module_event_info(void *data, const struct pw_module_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d module %d changed\n", rd->id, info->id);
+	pd->info = pw_module_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_module(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_module_events module_events = {
+	PW_VERSION_MODULE_EVENTS,
+	.info = module_event_info
+};
+
+static void node_event_info(void *data, const struct pw_node_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d node %d changed\n", rd->id, info->id);
+	pd->info = pw_node_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_node(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static void event_param(void *_data, int seq, uint32_t id,
+		uint32_t index, uint32_t next, const struct spa_pod *param)
+{
+        struct proxy_data *data = _data;
+	struct remote_data *rd = data->rd;
+
+	if (rd->data->interactive)
+		printf("remote %d object %d param %d index %d\n",
+				rd->id, data->global->id, id, index);
+
+	spa_debug_pod(2, NULL, param);
+}
+
+static const struct pw_node_events node_events = {
+	PW_VERSION_NODE_EVENTS,
+	.info = node_event_info,
+	.param = event_param
+};
+
+
+static void port_event_info(void *data, const struct pw_port_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d port %d changed\n", rd->id, info->id);
+	pd->info = pw_port_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_port(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_port_events port_events = {
+	PW_VERSION_PORT_EVENTS,
+	.info = port_event_info,
+	.param = event_param
+};
+
+static void factory_event_info(void *data, const struct pw_factory_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d factory %d changed\n", rd->id, info->id);
+	pd->info = pw_factory_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_factory(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_factory_events factory_events = {
+	PW_VERSION_FACTORY_EVENTS,
+	.info = factory_event_info
+};
+
+static void client_event_info(void *data, const struct pw_client_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d client %d changed\n", rd->id, info->id);
+	pd->info = pw_client_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_client(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static void client_event_permissions(void *_data, uint32_t index,
+		uint32_t n_permissions, const struct pw_permission *permissions)
+{
+        struct proxy_data *data = _data;
+	struct remote_data *rd = data->rd;
+	uint32_t i;
+
+	printf("remote %d node %d index %d\n",
+			rd->id, data->global->id, index);
+
+	for (i = 0; i < n_permissions; i++) {
+		if (permissions[i].id == PW_ID_ANY)
+			printf("  default:");
+		else
+			printf("  %u:", permissions[i].id);
+		printf(" "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(permissions[i].permissions));
+	}
+}
+
+static const struct pw_client_events client_events = {
+	PW_VERSION_CLIENT_EVENTS,
+	.info = client_event_info,
+	.permissions = client_event_permissions
+};
+
+static void link_event_info(void *data, const struct pw_link_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d link %d changed\n", rd->id, info->id);
+	pd->info = pw_link_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_link(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_link_events link_events = {
+	PW_VERSION_LINK_EVENTS,
+	.info = link_event_info
+};
+
+
+static void device_event_info(void *data, const struct pw_device_info *info)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	if (pd->info && rd->data->monitoring)
+		printf("remote %d device %d changed\n", rd->id, info->id);
+	pd->info = pw_device_info_update(pd->info, info);
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_device(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_device_events device_events = {
+	PW_VERSION_DEVICE_EVENTS,
+	.info = device_event_info,
+	.param = event_param
+};
+
+static void session_info_free(struct pw_session_info *info)
+{
+	free(info->params);
+	pw_properties_free ((struct pw_properties *)info->props);
+	free(info);
+}
+
+static void session_event_info(void *data,
+				const struct pw_session_info *update)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	struct pw_session_info *info = pd->info;
+
+	if (!info) {
+		info = pd->info = calloc(1, sizeof(*info));
+		info->id = update->id;
+	}
+	if (update->change_mask & PW_ENDPOINT_CHANGE_MASK_PARAMS) {
+		info->n_params = update->n_params;
+		free(info->params);
+		info->params = malloc(info->n_params * sizeof(struct spa_param_info));
+		memcpy(info->params, update->params,
+			info->n_params * sizeof(struct spa_param_info));
+	}
+	if (update->change_mask & PW_ENDPOINT_CHANGE_MASK_PROPS) {
+		pw_properties_free ((struct pw_properties *)info->props);
+		info->props =
+			(struct spa_dict *) pw_properties_new_dict (update->props);
+	}
+
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_session(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_session_events session_events = {
+	PW_VERSION_SESSION_EVENTS,
+	.info = session_event_info,
+	.param = event_param
+};
+
+static void endpoint_info_free(struct pw_endpoint_info *info)
+{
+	free(info->name);
+	free(info->media_class);
+	free(info->params);
+	pw_properties_free ((struct pw_properties *)info->props);
+	free(info);
+}
+
+static void endpoint_event_info(void *data,
+				const struct pw_endpoint_info *update)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	struct pw_endpoint_info *info = pd->info;
+
+	if (!info) {
+		info = pd->info = calloc(1, sizeof(*info));
+		info->id = update->id;
+		info->name = update->name ? strdup(update->name) : NULL;
+		info->media_class = update->media_class ? strdup(update->media_class) : NULL;
+		info->direction = update->direction;
+		info->flags = update->flags;
+	}
+	if (update->change_mask & PW_ENDPOINT_CHANGE_MASK_STREAMS)
+		info->n_streams = update->n_streams;
+	if (update->change_mask & PW_ENDPOINT_CHANGE_MASK_SESSION)
+		info->session_id = update->session_id;
+	if (update->change_mask & PW_ENDPOINT_CHANGE_MASK_PARAMS) {
+		info->n_params = update->n_params;
+		free(info->params);
+		info->params = malloc(info->n_params * sizeof(struct spa_param_info));
+		memcpy(info->params, update->params,
+			info->n_params * sizeof(struct spa_param_info));
+	}
+	if (update->change_mask & PW_ENDPOINT_CHANGE_MASK_PROPS) {
+		pw_properties_free ((struct pw_properties *)info->props);
+		info->props =
+			(struct spa_dict *) pw_properties_new_dict (update->props);
+	}
+
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_endpoint(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_endpoint_events endpoint_events = {
+	PW_VERSION_ENDPOINT_EVENTS,
+	.info = endpoint_event_info,
+	.param = event_param
+};
+
+static void endpoint_stream_info_free(struct pw_endpoint_stream_info *info)
+{
+	free(info->name);
+	free(info->params);
+	pw_properties_free ((struct pw_properties *)info->props);
+	free(info);
+}
+
+static void endpoint_stream_event_info(void *data,
+				const struct pw_endpoint_stream_info *update)
+{
+	struct proxy_data *pd = data;
+	struct remote_data *rd = pd->rd;
+	struct pw_endpoint_stream_info *info = pd->info;
+
+	if (!info) {
+		info = pd->info = calloc(1, sizeof(*info));
+		info->id = update->id;
+		info->endpoint_id = update->endpoint_id;
+		info->name = update->name ? strdup(update->name) : NULL;
+	}
+	if (update->change_mask & PW_ENDPOINT_STREAM_CHANGE_MASK_PARAMS) {
+		info->n_params = update->n_params;
+		free(info->params);
+		info->params = malloc(info->n_params * sizeof(struct spa_param_info));
+		memcpy(info->params, update->params,
+			info->n_params * sizeof(struct spa_param_info));
+	}
+	if (update->change_mask & PW_ENDPOINT_STREAM_CHANGE_MASK_PROPS) {
+		pw_properties_free ((struct pw_properties *)info->props);
+		info->props =
+			(struct spa_dict *) pw_properties_new_dict (update->props);
+	}
+
+	if (pd->global == NULL)
+		pd->global = pw_map_lookup(&rd->globals, info->id);
+	if (pd->global && pd->global->info_pending) {
+		info_endpoint_stream(pd);
+		pd->global->info_pending = false;
+	}
+}
+
+static const struct pw_endpoint_stream_events endpoint_stream_events = {
+	PW_VERSION_ENDPOINT_STREAM_EVENTS,
+	.info = endpoint_stream_event_info,
+	.param = event_param
+};
+
+static void
+removed_proxy (void *data)
+{
+	struct proxy_data *pd = data;
+	pw_proxy_destroy(pd->proxy);
+}
+
+static void
+destroy_proxy (void *data)
+{
+	struct proxy_data *pd = data;
+
+	spa_hook_remove(&pd->proxy_listener);
+	spa_hook_remove(&pd->object_listener);
+
+	if (pd->global)
+		pd->global->proxy = NULL;
+
+	if (pd->info == NULL)
+		return;
+
+	if (pd->class->destroy)
+		pd->class->destroy(pd->info);
+	pd->info = NULL;
+}
+
+static const struct pw_proxy_events proxy_events = {
+        PW_VERSION_PROXY_EVENTS,
+        .removed = removed_proxy,
+        .destroy = destroy_proxy,
+};
+
+static bool do_list_objects(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	pw_map_for_each(&rd->globals, print_global, args);
+	return true;
+}
+
+static const struct class core_class = {
+	.type = PW_TYPE_INTERFACE_Core,
+	.version = PW_VERSION_CORE,
+	.events = &core_events,
+	.destroy = (pw_destroy_t) pw_core_info_free,
+	.info = info_core,
+	.name_key = PW_KEY_CORE_NAME,
+};
+static const struct class module_class = {
+	.type = PW_TYPE_INTERFACE_Module,
+	.version = PW_VERSION_MODULE,
+	.events = &module_events,
+	.destroy = (pw_destroy_t) pw_module_info_free,
+	.info = info_module,
+	.name_key = PW_KEY_MODULE_NAME,
+};
+
+static const struct class factory_class = {
+	.type = PW_TYPE_INTERFACE_Factory,
+	.version = PW_VERSION_FACTORY,
+	.events = &factory_events,
+	.destroy = (pw_destroy_t) pw_factory_info_free,
+	.info = info_factory,
+	.name_key = PW_KEY_FACTORY_NAME,
+};
+
+static const struct class client_class = {
+	.type = PW_TYPE_INTERFACE_Client,
+	.version = PW_VERSION_CLIENT,
+	.events = &client_events,
+	.destroy = (pw_destroy_t) pw_client_info_free,
+	.info = info_client,
+	.name_key = PW_KEY_APP_NAME,
+};
+static const struct class device_class = {
+	.type = PW_TYPE_INTERFACE_Device,
+	.version = PW_VERSION_DEVICE,
+	.events = &device_events,
+	.destroy = (pw_destroy_t) pw_device_info_free,
+	.info = info_device,
+	.name_key = PW_KEY_DEVICE_NAME,
+};
+static const struct class node_class = {
+	.type = PW_TYPE_INTERFACE_Node,
+	.version = PW_VERSION_NODE,
+	.events = &node_events,
+	.destroy = (pw_destroy_t) pw_node_info_free,
+	.info = info_node,
+	.name_key = PW_KEY_NODE_NAME,
+};
+static const struct class port_class = {
+	.type = PW_TYPE_INTERFACE_Port,
+	.version = PW_VERSION_PORT,
+	.events = &port_events,
+	.destroy = (pw_destroy_t) pw_port_info_free,
+	.info = info_port,
+	.name_key = PW_KEY_PORT_NAME,
+};
+static const struct class link_class = {
+	.type = PW_TYPE_INTERFACE_Link,
+	.version = PW_VERSION_LINK,
+	.events = &link_events,
+	.destroy = (pw_destroy_t) pw_link_info_free,
+	.info = info_link,
+};
+static const struct class session_class = {
+	.type = PW_TYPE_INTERFACE_Session,
+	.version = PW_VERSION_SESSION,
+	.events = &session_events,
+	.destroy = (pw_destroy_t) session_info_free,
+	.info = info_session,
+};
+static const struct class endpoint_class = {
+	.type = PW_TYPE_INTERFACE_Endpoint,
+	.version = PW_VERSION_ENDPOINT,
+	.events = &endpoint_events,
+	.destroy = (pw_destroy_t) endpoint_info_free,
+	.info = info_endpoint,
+};
+static const struct class endpoint_stream_class = {
+	.type = PW_TYPE_INTERFACE_EndpointStream,
+	.version = PW_VERSION_ENDPOINT_STREAM,
+	.events = &endpoint_stream_events,
+	.destroy = (pw_destroy_t) endpoint_stream_info_free,
+	.info = info_endpoint_stream,
+};
+static const struct class metadata_class = {
+	.type = PW_TYPE_INTERFACE_Metadata,
+	.version = PW_VERSION_METADATA,
+	.name_key = PW_KEY_METADATA_NAME,
+};
+
+static const struct class *classes[] =
+{
+	&core_class,
+	&module_class,
+	&factory_class,
+	&client_class,
+	&device_class,
+	&node_class,
+	&port_class,
+	&link_class,
+	&session_class,
+	&endpoint_class,
+	&endpoint_stream_class,
+	&metadata_class,
+};
+
+static const struct class *find_class(const char *type, uint32_t version)
+{
+	SPA_FOR_EACH_ELEMENT_VAR(classes, c) {
+		if (spa_streq((*c)->type, type) &&
+		    (*c)->version <= version)
+			return *c;
+	}
+	return NULL;
+}
+
+static bool bind_global(struct remote_data *rd, struct global *global, char **error)
+{
+	const struct class *class;
+	struct proxy_data *pd;
+	struct pw_proxy *proxy;
+
+	class = find_class(global->type, global->version);
+	if (class == NULL) {
+		*error = spa_aprintf("unsupported type %s", global->type);
+		return false;
+	}
+	global->class = class;
+
+	proxy = pw_registry_bind(rd->registry,
+				       global->id,
+				       global->type,
+				       class->version,
+				       sizeof(struct proxy_data));
+
+	pd = pw_proxy_get_user_data(proxy);
+	pd->rd = rd;
+	pd->global = global;
+	pd->proxy = proxy;
+	pd->class = class;
+	pw_proxy_add_object_listener(proxy, &pd->object_listener, class->events, pd);
+	pw_proxy_add_listener(proxy, &pd->proxy_listener, &proxy_events, pd);
+
+	global->proxy = proxy;
+
+	rd->prompt_pending = pw_core_sync(rd->core, 0, 0);
+
+	return true;
+}
+
+static bool do_global_info(struct global *global, char **error)
+{
+	struct remote_data *rd = global->rd;
+	struct proxy_data *pd;
+
+	if (global->proxy == NULL) {
+		if (!bind_global(rd, global, error))
+			return false;
+		global->info_pending = true;
+	} else {
+		pd = pw_proxy_get_user_data(global->proxy);
+		if (pd->class->info)
+			pd->class->info(pd);
+	}
+	return true;
+}
+static int do_global_info_all(void *obj, void *data)
+{
+	struct global *global = obj;
+	char *error;
+
+	if (global == NULL)
+		return 0;
+
+	if (!do_global_info(global, &error)) {
+		fprintf(stderr, "info: %s\n", error);
+		free(error);
+	}
+	return 0;
+}
+
+static bool do_info(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[1];
+        int n;
+	struct global *global;
+
+	n = pw_split_ip(args, WHITESPACE, 1, a);
+	if (n < 1) {
+		*error = spa_aprintf("%s <object-id>|all", cmd);
+		return false;
+	}
+	if (spa_streq(a[0], "all")) {
+		pw_map_for_each(&rd->globals, do_global_info_all, NULL);
+	}
+	else {
+		global = find_global(rd, a[0]);
+		if (global == NULL) {
+			*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+			return false;
+		}
+		return do_global_info(global, error);
+	}
+	return true;
+}
+
+static bool do_create_device(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[2];
+	int n;
+	uint32_t id;
+	struct pw_proxy *proxy;
+	struct pw_properties *props = NULL;
+	struct proxy_data *pd;
+
+	n = pw_split_ip(args, WHITESPACE, 2, a);
+	if (n < 1) {
+		*error = spa_aprintf("%s <factory-name> [<properties>]", cmd);
+		return false;
+	}
+	if (n == 2)
+		props = pw_properties_new_string(a[1]);
+
+	proxy = pw_core_create_object(rd->core, a[0],
+					    PW_TYPE_INTERFACE_Device,
+					    PW_VERSION_DEVICE,
+					    props ? &props->dict : NULL,
+					    sizeof(struct proxy_data));
+
+	pw_properties_free(props);
+
+	pd = pw_proxy_get_user_data(proxy);
+	pd->rd = rd;
+	pd->proxy = proxy;
+	pd->class = &device_class;
+	pw_proxy_add_object_listener(proxy, &pd->object_listener, &device_events, pd);
+	pw_proxy_add_listener(proxy, &pd->proxy_listener, &proxy_events, pd);
+
+	id = pw_map_insert_new(&data->vars, proxy);
+	if (rd->data->interactive)
+		printf("%d = @proxy:%d\n", id, pw_proxy_get_id(proxy));
+
+	return true;
+}
+
+static bool do_create_node(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[2];
+        int n;
+	uint32_t id;
+	struct pw_proxy *proxy;
+	struct pw_properties *props = NULL;
+	struct proxy_data *pd;
+
+	n = pw_split_ip(args, WHITESPACE, 2, a);
+	if (n < 1) {
+		*error = spa_aprintf("%s <factory-name> [<properties>]", cmd);
+		return false;
+	}
+	if (n == 2)
+		props = pw_properties_new_string(a[1]);
+
+	proxy = pw_core_create_object(rd->core, a[0],
+					    PW_TYPE_INTERFACE_Node,
+					    PW_VERSION_NODE,
+					    props ? &props->dict : NULL,
+					    sizeof(struct proxy_data));
+
+	pw_properties_free(props);
+
+	pd = pw_proxy_get_user_data(proxy);
+	pd->rd = rd;
+	pd->proxy = proxy;
+        pd->class = &node_class;
+        pw_proxy_add_object_listener(proxy, &pd->object_listener, &node_events, pd);
+        pw_proxy_add_listener(proxy, &pd->proxy_listener, &proxy_events, pd);
+
+	id = pw_map_insert_new(&data->vars, proxy);
+	if (rd->data->interactive)
+		printf("%d = @proxy:%d\n", id, pw_proxy_get_id(proxy));
+
+	return true;
+}
+
+static bool do_destroy(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[1];
+        int n;
+	struct global *global;
+
+	n = pw_split_ip(args, WHITESPACE, 1, a);
+	if (n < 1) {
+		*error = spa_aprintf("%s <object-id>", cmd);
+		return false;
+	}
+	global = find_global(rd, a[0]);
+	if (global == NULL) {
+		*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+		return false;
+	}
+	pw_registry_destroy(rd->registry, global->id);
+
+	return true;
+}
+
+static struct global *
+obj_global_port(struct remote_data *rd, struct global *global, const char *port_direction, const char *port_id)
+{
+	struct global *global_port_found = NULL;
+	uint32_t *ports = NULL;
+	int port_count;
+
+	port_count = children_of(rd, global->id, PW_TYPE_INTERFACE_Port, &ports);
+
+	if (port_count <= 0)
+		return NULL;
+
+	for (int i = 0; i < port_count; i++) {
+		struct global *global_port = obj_global(rd, ports[i]);
+
+		if (!global_port)
+			continue;
+
+		struct spa_dict *props_port = global_props(global_port);
+
+		if (spa_streq(spa_dict_lookup(props_port, "port.direction"), port_direction)
+				&& spa_streq(spa_dict_lookup(props_port, "port.id"), port_id)) {
+			global_port_found = global_port;
+			break;
+		}
+	}
+
+	free(ports);
+	return global_port_found;
+}
+
+static void create_link_with_properties(struct data *data, struct pw_properties *props)
+{
+	struct remote_data *rd = data->current;
+	uint32_t id;
+	struct pw_proxy *proxy;
+	struct proxy_data *pd;
+
+	proxy = (struct pw_proxy*)pw_core_create_object(rd->core,
+					  "link-factory",
+					  PW_TYPE_INTERFACE_Link,
+					  PW_VERSION_LINK,
+					  props ? &props->dict : NULL,
+					  sizeof(struct proxy_data));
+
+	pd = pw_proxy_get_user_data(proxy);
+	pd->rd = rd;
+	pd->proxy = proxy;
+	pd->class = &link_class;
+	pw_proxy_add_object_listener(proxy, &pd->object_listener, &link_events, pd);
+	pw_proxy_add_listener(proxy, &pd->proxy_listener, &proxy_events, pd);
+
+	id = pw_map_insert_new(&data->vars, proxy);
+	if (rd->data->interactive)
+		printf("%d = @proxy:%d\n", id, pw_proxy_get_id((struct pw_proxy*)proxy));
+}
+
+static bool do_create_link(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[5];
+	int n;
+	struct pw_properties *props = NULL;
+
+	n = pw_split_ip(args, WHITESPACE, 5, a);
+	if (n < 4) {
+		*error = spa_aprintf("%s <node-id> <port> <node-id> <port> [<properties>]", cmd);
+		return false;
+	}
+	if (n == 5)
+		props = pw_properties_new_string(a[4]);
+	else
+		props = pw_properties_new(NULL, NULL);
+
+	if (!spa_streq(a[0], "-"))
+		pw_properties_set(props, PW_KEY_LINK_OUTPUT_NODE, a[0]);
+	if (!spa_streq(a[1], "-"))
+		pw_properties_set(props, PW_KEY_LINK_OUTPUT_PORT, a[1]);
+	if (!spa_streq(a[2], "-"))
+		pw_properties_set(props, PW_KEY_LINK_INPUT_NODE, a[2]);
+	if (!spa_streq(a[3], "-"))
+		pw_properties_set(props, PW_KEY_LINK_INPUT_PORT, a[3]);
+
+	if (spa_streq(a[1], "*") && spa_streq(a[3], "*")) {
+		struct global *global_out, *global_in;
+		struct proxy_data *pd_out, *pd_in;
+		uint32_t n_output_ports, n_input_ports;
+
+		global_out = find_global(rd, a[0]);
+		if (global_out == NULL) {
+			*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+			return false;
+		}
+		global_in = find_global(rd, a[2]);
+		if (global_in == NULL) {
+			*error = spa_aprintf("%s: unknown global '%s'", cmd, a[2]);
+			return false;
+		}
+
+		pd_out = pw_proxy_get_user_data(global_out->proxy);
+		pd_in = pw_proxy_get_user_data(global_in->proxy);
+
+		n_output_ports = ((struct pw_node_info *)pd_out->info)->n_output_ports;
+		n_input_ports = ((struct pw_node_info *)pd_in->info)->n_input_ports;
+
+		if (n_output_ports != n_input_ports) {
+			*error = spa_aprintf("%s: Number of ports don't match (%u != %u)", cmd, n_output_ports, n_input_ports);
+			return false;
+		}
+
+		for (uint32_t i = 0; i < n_output_ports; i++) {
+			char port_id[4];
+			struct global *global_port_out, *global_port_in;
+
+			snprintf(port_id, 4, "%d", i);
+
+			global_port_out = obj_global_port(rd, global_out, "out", port_id);
+			global_port_in = obj_global_port(rd, global_in, "in", port_id);
+
+			if (!global_port_out || !global_port_in)
+				continue;
+
+			pw_properties_setf(props, PW_KEY_LINK_OUTPUT_PORT, "%d", global_port_out->id);
+			pw_properties_setf(props, PW_KEY_LINK_INPUT_PORT, "%d", global_port_in->id);
+
+			create_link_with_properties(data, props);
+		}
+	} else
+		create_link_with_properties(data, props);
+
+	pw_properties_free(props);
+
+	return true;
+}
+
+static bool do_export_node(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	struct pw_global *global;
+	struct pw_node *node;
+	struct pw_proxy *proxy;
+	char *a[2];
+	int n, idx;
+	uint32_t id;
+
+	n = pw_split_ip(args, WHITESPACE, 2, a);
+	if (n < 1) {
+		*error = spa_aprintf("%s <node-id> [<remote-var>]", cmd);
+		return false;
+	}
+	if (n == 2) {
+		idx = atoi(a[1]);
+		rd = pw_map_lookup(&data->vars, idx);
+		if (rd == NULL)
+			goto no_remote;
+	}
+
+	global = pw_context_find_global(data->context, atoi(a[0]));
+	if (global == NULL) {
+		*error = spa_aprintf("object %d does not exist", atoi(a[0]));
+		return false;
+	}
+	if (!pw_global_is_type(global, PW_TYPE_INTERFACE_Node)) {
+		*error = spa_aprintf("object %d is not a node", atoi(a[0]));
+		return false;
+	}
+	node = pw_global_get_object(global);
+	proxy = pw_core_export(rd->core, PW_TYPE_INTERFACE_Node, NULL, node, 0);
+
+	id = pw_map_insert_new(&data->vars, proxy);
+	if (rd->data->interactive)
+		printf("%d = @proxy:%d\n", id, pw_proxy_get_id((struct pw_proxy*)proxy));
+
+	return true;
+
+      no_remote:
+        *error = spa_aprintf("Remote %d does not exist", idx);
+	return false;
+}
+
+static bool do_enum_params(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[2];
+	int n;
+	uint32_t param_id;
+	const struct spa_type_info *ti;
+	struct global *global;
+
+	n = pw_split_ip(args, WHITESPACE, 2, a);
+	if (n < 2) {
+		*error = spa_aprintf("%s <object-id> <param-id>", cmd);
+		return false;
+	}
+
+	ti = spa_debug_type_find_short(spa_type_param, a[1]);
+	if (ti == NULL) {
+		*error = spa_aprintf("%s: unknown param type: %s", cmd, a[1]);
+		return false;
+	}
+	param_id = ti->type;
+
+	global = find_global(rd, a[0]);
+	if (global == NULL) {
+		*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+		return false;
+	}
+	if (global->proxy == NULL) {
+		if (!bind_global(rd, global, error))
+			return false;
+	}
+
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Node))
+		pw_node_enum_params((struct pw_node*)global->proxy, 0,
+			param_id, 0, 0, NULL);
+	else if (spa_streq(global->type, PW_TYPE_INTERFACE_Port))
+		pw_port_enum_params((struct pw_port*)global->proxy, 0,
+			param_id, 0, 0, NULL);
+	else if (spa_streq(global->type, PW_TYPE_INTERFACE_Device))
+		pw_device_enum_params((struct pw_device*)global->proxy, 0,
+			param_id, 0, 0, NULL);
+	else if (spa_streq(global->type, PW_TYPE_INTERFACE_Endpoint))
+		pw_endpoint_enum_params((struct pw_endpoint*)global->proxy, 0,
+			param_id, 0, 0, NULL);
+	else {
+		*error = spa_aprintf("enum-params not implemented on object %d type:%s",
+				atoi(a[0]), global->type);
+		return false;
+	}
+	return true;
+}
+
+static bool do_set_param(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[3];
+	int res, n;
+	uint32_t param_id;
+	struct global *global;
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+	const struct spa_type_info *ti;
+	struct spa_pod *pod;
+
+	n = pw_split_ip(args, WHITESPACE, 3, a);
+	if (n < 3) {
+		*error = spa_aprintf("%s <object-id> <param-id> <param-json>", cmd);
+		return false;
+	}
+
+	global = find_global(rd, a[0]);
+	if (global == NULL) {
+		*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+		return false;
+	}
+	if (global->proxy == NULL) {
+		if (!bind_global(rd, global, error))
+			return false;
+	}
+
+	ti = spa_debug_type_find_short(spa_type_param, a[1]);
+	if (ti == NULL) {
+		*error = spa_aprintf("%s: unknown param type: %s", cmd, a[1]);
+		return false;
+	}
+	if ((res = spa_json_to_pod(&b, 0, ti, a[2], strlen(a[2]))) < 0) {
+		*error = spa_aprintf("%s: can't make pod: %s", cmd, spa_strerror(res));
+		return false;
+	}
+	if ((pod = spa_pod_builder_deref(&b, 0)) == NULL) {
+		*error = spa_aprintf("%s: can't make pod", cmd);
+		return false;
+	}
+	spa_debug_pod(0, NULL, pod);
+
+	param_id = ti->type;
+
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Node))
+		pw_node_set_param((struct pw_node*)global->proxy,
+				param_id, 0, pod);
+	else if (spa_streq(global->type, PW_TYPE_INTERFACE_Device))
+		pw_device_set_param((struct pw_device*)global->proxy,
+				param_id, 0, pod);
+	else if (spa_streq(global->type, PW_TYPE_INTERFACE_Endpoint))
+		pw_endpoint_set_param((struct pw_endpoint*)global->proxy,
+				param_id, 0, pod);
+	else {
+		*error = spa_aprintf("set-param not implemented on object %d type:%s",
+				atoi(a[0]), global->type);
+		return false;
+	}
+	return true;
+}
+
+static bool do_permissions(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[3];
+	int n;
+	uint32_t p;
+	struct global *global;
+	struct pw_permission permissions[1];
+
+	n = pw_split_ip(args, WHITESPACE, 3, a);
+	if (n < 3) {
+		*error = spa_aprintf("%s <client-id> <object> <permission>", cmd);
+		return false;
+	}
+
+	global = find_global(rd, a[0]);
+	if (global == NULL) {
+		*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+		return false;
+	}
+	if (!spa_streq(global->type, PW_TYPE_INTERFACE_Client)) {
+		*error = spa_aprintf("object %d is not a client", atoi(a[0]));
+		return false;
+	}
+	if (global->proxy == NULL) {
+		if (!bind_global(rd, global, error))
+			return false;
+	}
+
+	p = strtol(a[2], NULL, 0);
+	if (rd->data->interactive)
+		printf("setting permissions: "PW_PERMISSION_FORMAT"\n",
+				PW_PERMISSION_ARGS(p));
+
+	permissions[0] = PW_PERMISSION_INIT(atoi(a[1]), p);
+	pw_client_update_permissions((struct pw_client*)global->proxy,
+			1, permissions);
+
+	return true;
+}
+
+static bool do_get_permissions(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[3];
+        int n;
+	struct global *global;
+
+	n = pw_split_ip(args, WHITESPACE, 1, a);
+	if (n < 1) {
+		*error = spa_aprintf("%s <client-id>", cmd);
+		return false;
+	}
+
+	global = find_global(rd, a[0]);
+	if (global == NULL) {
+		*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+		return false;
+	}
+	if (!spa_streq(global->type, PW_TYPE_INTERFACE_Client)) {
+		*error = spa_aprintf("object %d is not a client", atoi(a[0]));
+		return false;
+	}
+	if (global->proxy == NULL) {
+		if (!bind_global(rd, global, error))
+			return false;
+	}
+	pw_client_get_permissions((struct pw_client*)global->proxy,
+			0, UINT32_MAX);
+
+	return true;
+}
+
+static bool do_send_command(struct data *data, const char *cmd, char *args, char **error)
+{
+	struct remote_data *rd = data->current;
+	char *a[3];
+	int res, n;
+	struct global *global;
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+	const struct spa_type_info *ti;
+	struct spa_pod *pod;
+
+	n = pw_split_ip(args, WHITESPACE, 3, a);
+	if (n < 3) {
+		*error = spa_aprintf("%s <object-id> <command-id> <command-json>", cmd);
+		return false;
+	}
+
+	global = find_global(rd, a[0]);
+	if (global == NULL) {
+		*error = spa_aprintf("%s: unknown global '%s'", cmd, a[0]);
+		return false;
+	}
+	if (global->proxy == NULL) {
+		if (!bind_global(rd, global, error))
+			return false;
+	}
+
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Node)) {
+		ti = spa_debug_type_find_short(spa_type_node_command_id, a[1]);
+	} else {
+		*error = spa_aprintf("send-command not implemented on object %d type:%s",
+				atoi(a[0]), global->type);
+		return false;
+	}
+
+	if (ti == NULL) {
+		*error = spa_aprintf("%s: unknown node command type: %s", cmd, a[1]);
+		return false;
+	}
+	if ((res = spa_json_to_pod(&b, 0, ti, a[2], strlen(a[2]))) < 0) {
+		*error = spa_aprintf("%s: can't make pod: %s", cmd, spa_strerror(res));
+		return false;
+	}
+	if ((pod = spa_pod_builder_deref(&b, 0)) == NULL) {
+		*error = spa_aprintf("%s: can't make pod", cmd);
+		return false;
+	}
+	spa_debug_pod(0, NULL, pod);
+
+	pw_node_send_command((struct pw_node*)global->proxy, (struct spa_command*)pod);
+	return true;
+}
+
+static struct global *
+obj_global(struct remote_data *rd, uint32_t id)
+{
+	struct global *global;
+	struct proxy_data *pd;
+
+	if (!rd)
+		return NULL;
+
+	global = pw_map_lookup(&rd->globals, id);
+	if (!global)
+		return NULL;
+
+	pd = pw_proxy_get_user_data(global->proxy);
+	if (!pd || !pd->info)
+		return NULL;
+
+	return global;
+}
+
+static struct spa_dict *
+global_props(struct global *global)
+{
+	struct proxy_data *pd;
+
+	if (!global)
+		return NULL;
+
+	pd = pw_proxy_get_user_data(global->proxy);
+	if (!pd || !pd->info)
+		return NULL;
+
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Core))
+		return ((struct pw_core_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Module))
+		return ((struct pw_module_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Device))
+		return ((struct pw_device_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Node))
+		return ((struct pw_node_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Port))
+		return ((struct pw_port_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Factory))
+		return ((struct pw_factory_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Client))
+		return ((struct pw_client_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Link))
+		return ((struct pw_link_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Session))
+		return ((struct pw_session_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_Endpoint))
+		return ((struct pw_endpoint_info *)pd->info)->props;
+	if (spa_streq(global->type, PW_TYPE_INTERFACE_EndpointStream))
+		return ((struct pw_endpoint_stream_info *)pd->info)->props;
+
+	return NULL;
+}
+
+static const char *
+global_lookup(struct global *global, const char *key)
+{
+	struct spa_dict *dict;
+
+	dict = global_props(global);
+	if (!dict)
+		return NULL;
+	return spa_dict_lookup(dict, key);
+}
+
+
+static int
+children_of(struct remote_data *rd, uint32_t parent_id,
+	    const char *child_type, uint32_t **children)
+{
+	const char *parent_type;
+	union pw_map_item *item;
+	struct global *global;
+	struct proxy_data *pd;
+	const char *parent_key = NULL, *child_key = NULL;
+	const char *parent_value = NULL, *child_value = NULL;
+	int pass, i, count;
+
+	if (!rd || !children)
+		return -1;
+
+	/* get the device info */
+	global = obj_global(rd, parent_id);
+	if (!global)
+		return -1;
+	parent_type = global->type;
+	pd = pw_proxy_get_user_data(global->proxy);
+	if (!pd || !pd->info)
+		return -1;
+
+	/* supported combinations */
+	if (spa_streq(parent_type, PW_TYPE_INTERFACE_Device) &&
+	    spa_streq(child_type, PW_TYPE_INTERFACE_Node)) {
+		parent_key = PW_KEY_OBJECT_ID;
+		child_key = PW_KEY_DEVICE_ID;
+	} else if (spa_streq(parent_type, PW_TYPE_INTERFACE_Node) &&
+		   spa_streq(child_type, PW_TYPE_INTERFACE_Port)) {
+		parent_key = PW_KEY_OBJECT_ID;
+		child_key = PW_KEY_NODE_ID;
+	} else if (spa_streq(parent_type, PW_TYPE_INTERFACE_Module) &&
+		   spa_streq(child_type, PW_TYPE_INTERFACE_Factory)) {
+		parent_key = PW_KEY_OBJECT_ID;
+		child_key = PW_KEY_MODULE_ID;
+	} else if (spa_streq(parent_type, PW_TYPE_INTERFACE_Factory) &&
+		   spa_streq(child_type, PW_TYPE_INTERFACE_Device)) {
+		parent_key = PW_KEY_OBJECT_ID;
+		child_key = PW_KEY_FACTORY_ID;
+	} else
+		return -1;
+
+	/* get the parent key value */
+	if (parent_key) {
+		parent_value = global_lookup(global, parent_key);
+		if (!parent_value)
+			return -1;
+	}
+
+	count = 0;
+	*children = NULL;
+	i = 0;
+	for (pass = 1; pass <= 2; pass++) {
+		if (pass == 2) {
+			count = i;
+			if (!count)
+				return 0;
+
+			*children = malloc(sizeof(uint32_t) * count);
+			if (!*children)
+				return -1;
+		}
+		i = 0;
+		pw_array_for_each(item, &rd->globals.items) {
+			if (pw_map_item_is_free(item) || item->data == NULL)
+				continue;
+
+			global = item->data;
+
+			if (!spa_streq(global->type, child_type))
+				continue;
+
+			pd = pw_proxy_get_user_data(global->proxy);
+			if (!pd || !pd->info)
+				return -1;
+
+			if (child_key) {
+				/* get the device path */
+				child_value = global_lookup(global, child_key);
+				if (!child_value)
+					continue;
+			}
+
+			/* match? */
+			if (!spa_streq(parent_value, child_value))
+				continue;
+
+			if (*children)
+				(*children)[i] = global->id;
+			i++;
+
+		}
+	}
+	return count;
+}
+
+#define INDENT(_level) \
+	({ \
+		int __level = (_level); \
+		char *_indent = alloca(__level + 1); \
+		memset(_indent, '\t', __level); \
+		_indent[__level] = '\0'; \
+		(const char *)_indent; \
+	})
+
+static bool parse(struct data *data, char *buf, char **error)
+{
+	char *a[2];
+	int n;
+	char *p, *cmd, *args;
+
+	if ((p = strchr(buf, '#')))
+		*p = '\0';
+
+	p = pw_strip(buf, "\n\r \t");
+
+	if (*p == '\0')
+		return true;
+
+	n = pw_split_ip(p, WHITESPACE, 2, a);
+	if (n < 1)
+		return true;
+
+	cmd = a[0];
+	args = n > 1 ? a[1] : "";
+
+	SPA_FOR_EACH_ELEMENT_VAR(command_list, c) {
+		if (spa_streq(c->name, cmd) ||
+		    spa_streq(c->alias, cmd)) {
+			return c->func(data, cmd, args, error);
+		}
+	}
+        *error = spa_aprintf("Command \"%s\" does not exist. Type 'help' for usage.", cmd);
+	return false;
+}
+
+/* We need a global variable, readline doesn't have a closure arg */
+static struct data *input_dataptr;
+
+static void input_process_line(char *line)
+{
+	struct data *d = input_dataptr;
+	char *error;
+
+	if (!line)
+		line = strdup("quit");
+
+	if (line[0] != '\0') {
+#ifdef HAVE_READLINE
+		add_history(line);
+#endif
+		if (!parse(d, line, &error)) {
+			fprintf(stderr, "Error: \"%s\"\n", error);
+			free(error);
+		}
+	}
+	free(line);
+}
+
+static void do_input(void *data, int fd, uint32_t mask)
+{
+	struct data *d = data;
+
+	if (mask & SPA_IO_IN) {
+		input_dataptr = d;
+#ifdef HAVE_READLINE
+		rl_callback_read_char();
+#else
+		{
+			char *line = NULL;
+			size_t s = 0;
+
+			if (getline(&line, &s, stdin) < 0) {
+				free(line);
+				line = NULL;
+			}
+			input_process_line(line);
+		}
+#endif
+
+		if (d->current == NULL)
+			pw_main_loop_quit(d->loop);
+		else  {
+			struct remote_data *rd = d->current;
+			if (rd->core)
+				rd->prompt_pending = pw_core_sync(rd->core, 0, 0);
+		}
+	}
+}
+
+#ifdef HAVE_READLINE
+static char *
+readline_match_command(const char *text, int state)
+{
+	static size_t idx;
+	static int len;
+
+	if (!state) {
+		idx = 0;
+		len = strlen(text);
+	}
+
+	while (idx < SPA_N_ELEMENTS(command_list))  {
+		const char *name = command_list[idx].name;
+		const char *alias = command_list[idx].alias;
+
+		idx++;
+		if (spa_strneq(name, text, len) || spa_strneq(alias, text, len))
+			return strdup(name);
+	}
+
+	return NULL;
+}
+
+static char **
+readline_command_completion(const char *text, int start, int end)
+{
+	char **matches = NULL;
+
+	/* Only try to complete the first word in a line */
+	if (start == 0)
+		matches = rl_completion_matches(text, readline_match_command);
+
+	/* Don't fall back to filename completion */
+	rl_attempted_completion_over = true;
+
+	return matches;
+}
+
+static void readline_init(void)
+{
+	rl_attempted_completion_function = readline_command_completion;
+	rl_callback_handler_install(">> ", input_process_line);
+}
+
+static void readline_cleanup(void)
+{
+	rl_callback_handler_remove();
+}
+#endif
+
+static void do_quit_on_signal(void *data, int signal_number)
+{
+	struct data *d = data;
+	d->quit = true;
+	pw_main_loop_quit(d->loop);
+}
+
+static void show_help(struct data *data, const char *name, bool error)
+{
+	fprintf(error ? stderr : stdout, _("%s [options] [command]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -d, --daemon                          Start as daemon (Default false)\n"
+		"  -r, --remote                          Remote daemon name\n"
+		"  -m, --monitor                         Monitor activity\n\n"),
+		name);
+
+	do_help(data, "help", "", NULL);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct pw_loop *l;
+	char *opt_remote = NULL;
+	char *error;
+	bool daemon = false, monitor = false;
+	struct remote_data *rd;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "monitor",	no_argument,		NULL, 'm' },
+		{ "daemon",	no_argument,		NULL, 'd' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ NULL,	0, NULL, 0}
+	};
+	int c, i;
+
+	setlinebuf(stdout);
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	while ((c = getopt_long(argc, argv, "hVmdr:", 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 'd':
+			daemon = true;
+			break;
+		case 'm':
+			monitor = true;
+			break;
+		case 'r':
+			opt_remote = optarg;
+			break;
+		default:
+			show_help(&data, argv[0], true);
+			return -1;
+		}
+	}
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "Broken installation: %m\n");
+		return -1;
+	}
+	l = pw_main_loop_get_loop(data.loop);
+	pw_loop_add_signal(l, SIGINT, do_quit_on_signal, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit_on_signal, &data);
+
+	spa_list_init(&data.remotes);
+	pw_map_init(&data.vars, 64, 16);
+
+	data.context = pw_context_new(l,
+			pw_properties_new(
+				PW_KEY_CORE_DAEMON, daemon ? "true" : NULL,
+				NULL),
+			0);
+	if (data.context == NULL) {
+		fprintf(stderr, "Can't create context: %m\n");
+		return -1;
+	}
+
+	pw_context_load_module(data.context, "libpipewire-module-link-factory", NULL, NULL);
+
+	if (!do_connect(&data, "connect", opt_remote, &error)) {
+		fprintf(stderr, "Error: \"%s\"\n", error);
+		return -1;
+	}
+
+	if (optind == argc) {
+		data.interactive = true;
+
+		printf("Welcome to PipeWire version %s. Type 'help' for usage.\n",
+				pw_get_library_version());
+
+#ifdef HAVE_READLINE
+		readline_init();
+#endif
+
+		pw_loop_add_io(l, STDIN_FILENO, SPA_IO_IN|SPA_IO_HUP, false, do_input, &data);
+
+		pw_main_loop_run(data.loop);
+
+#ifdef HAVE_READLINE
+		readline_cleanup();
+#endif
+	} else {
+		char buf[4096], *p, *error;
+
+		p = buf;
+		for (i = optind; i < argc; i++) {
+			p = stpcpy(p, argv[i]);
+			p = stpcpy(p, " ");
+		}
+
+		pw_main_loop_run(data.loop);
+
+		if (!parse(&data, buf, &error)) {
+			fprintf(stderr, "Error: \"%s\"\n", error);
+			free(error);
+		}
+		data.current->prompt_pending = pw_core_sync(data.current->core, 0, 0);
+		while (!data.quit && data.current) {
+			pw_main_loop_run(data.loop);
+			if (!monitor)
+				break;
+		}
+	}
+	spa_list_consume(rd, &data.remotes, link)
+		remote_data_free(rd);
+
+	pw_context_destroy(data.context);
+	pw_main_loop_destroy(data.loop);
+	pw_map_clear(&data.vars);
+	pw_deinit();
+
+	return 0;
+}
diff --git a/src/tools/pw-dot.c b/src/tools/pw-dot.c
new file mode 100644
index 0000000..30eb780
--- /dev/null
+++ b/src/tools/pw-dot.c
@@ -0,0 +1,1169 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Collabora Ltd.
+ *
+ * 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 <stdio.h>
+#include <signal.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/utils/json.h>
+#include <spa/debug/types.h>
+
+#include <pipewire/pipewire.h>
+
+#define GLOBAL_ID_NONE UINT32_MAX
+#define DEFAULT_DOT_PATH "pw.dot"
+
+struct global;
+
+typedef void (*draw_t)(struct global *g);
+typedef void *(*info_update_t) (void *info, const void *update);
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct spa_list globals;
+	char *dot_str;
+	const char *dot_rankdir;
+	bool dot_orthoedges;
+
+	bool show_all;
+	bool show_smart;
+	bool show_detail;
+};
+
+struct global {
+	struct spa_list link;
+
+	struct data *data;
+	struct pw_proxy *proxy;
+
+	uint32_t id;
+#define INTERFACE_Port		0
+#define INTERFACE_Node		1
+#define INTERFACE_Link		2
+#define INTERFACE_Client	3
+#define INTERFACE_Device	4
+#define INTERFACE_Module	5
+#define INTERFACE_Factory	6
+	uint32_t type;
+	void *info;
+
+	pw_destroy_t info_destroy;
+	info_update_t info_update;
+	draw_t draw;
+
+	struct spa_hook proxy_listener;
+	struct spa_hook object_listener;
+};
+
+static char *dot_str_new(void)
+{
+        return strdup("");
+}
+
+static void dot_str_clear(char **str)
+{
+	if (str && *str) {
+		  free(*str);
+		  *str = NULL;
+	}
+}
+
+static SPA_PRINTF_FUNC(2,0) void dot_str_vadd(char **str, const char *fmt, va_list varargs)
+{
+	char *res = NULL;
+	char *fmt2 = NULL;
+
+	spa_return_if_fail(str != NULL);
+	spa_return_if_fail(fmt != NULL);
+
+	if (asprintf(&fmt2, "%s%s", *str, fmt) < 0) {
+		spa_assert_not_reached();
+		return;
+	}
+
+	if (vasprintf(&res, fmt2, varargs) < 0) {
+		free (fmt2);
+		spa_assert_not_reached();
+		return;
+	}
+	free (fmt2);
+
+	free(*str);
+	*str = res;
+}
+
+static SPA_PRINTF_FUNC(2,3) void dot_str_add(char **str, const char *fmt, ...)
+{
+	va_list varargs;
+	va_start(varargs, fmt);
+	dot_str_vadd(str, fmt, varargs);
+	va_end(varargs);
+}
+
+static void draw_dict(char **str, const char *title,
+		      const struct spa_dict *props)
+{
+	const struct spa_dict_item *item;
+
+	dot_str_add(str, "%s:\\l", title);
+	if (props == NULL || props->n_items == 0) {
+		dot_str_add(str, "- none\\l");
+		return;
+	}
+
+	spa_dict_for_each(item, props) {
+		if (item->value)
+			dot_str_add(str, "- %s: %s\\l", item->key, item->value);
+		else
+			dot_str_add(str, "- %s: (null)\\l", item->key);
+	}
+}
+
+static SPA_PRINTF_FUNC(6,0) void draw_vlabel(char **str, const char *name, uint32_t id, bool detail,
+		       const struct spa_dict *props, const char *fmt, va_list varargs)
+{
+	/* draw the label header */
+	dot_str_add(str, "%s_%u [label=\"", name, id);
+
+	/* draw the label body */
+	dot_str_vadd(str, fmt, varargs);
+
+	if (detail)
+		draw_dict(str, "properties", props);
+
+	/*draw the label footer */
+	dot_str_add(str, "%s", "\"];\n");
+}
+
+static SPA_PRINTF_FUNC(6,7) void draw_label(char **str, const char *name, uint32_t id, bool detail,
+		       const struct spa_dict *props, const char *fmt, ...)
+{
+	va_list varargs;
+	va_start(varargs, fmt);
+	draw_vlabel(str, name, id, detail, props, fmt, varargs);
+	va_end(varargs);
+}
+
+static void draw_port(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Port);
+
+	struct pw_port_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str,
+		"port_%u [shape=box style=filled fillcolor=%s];\n",
+		g->id,
+		info->direction == PW_DIRECTION_INPUT ? "lightslateblue" : "lightcoral"
+	);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"port", g->id, g->data->show_detail, info->props,
+		"port_id: %u\\lname: %s\\ldirection: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_PORT_NAME),
+		pw_direction_as_string(info->direction)
+	);
+}
+
+
+static void draw_node(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Node);
+
+	struct pw_node_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	const char *client_id_str, *factory_id_str;
+	uint32_t client_id, factory_id;
+
+	client_id_str = spa_dict_lookup(info->props, PW_KEY_CLIENT_ID);
+	factory_id_str = spa_dict_lookup(info->props, PW_KEY_FACTORY_ID);
+	client_id = client_id_str ? (uint32_t)atoi(client_id_str) : GLOBAL_ID_NONE;
+	factory_id = factory_id_str ? (uint32_t)atoi(factory_id_str) : GLOBAL_ID_NONE;
+
+	/* draw the node header */
+	dot_str_add(dot_str, "subgraph cluster_node_%u {\n", g->id);
+	dot_str_add(dot_str, "bgcolor=palegreen;\n");
+
+	/* draw the label header */
+	dot_str_add(dot_str, "label=\"");
+
+	/* draw the label body */
+	dot_str_add(dot_str, "node_id: %u\\lname: %s\\lmedia_class: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_NODE_NAME),
+		spa_dict_lookup(info->props, PW_KEY_MEDIA_CLASS));
+
+	if (g->data->show_detail)
+		draw_dict(dot_str, "properties", info->props);
+
+	/*draw the label footer */
+	dot_str_add(dot_str, "%s", "\"\n");
+
+	/* draw all node ports */
+	struct global *p;
+	const char *prop_node_id;
+	spa_list_for_each(p, &g->data->globals, link) {
+		struct pw_port_info *pinfo;
+		if (p->info == NULL)
+			continue;
+		if (p->type != INTERFACE_Port)
+			continue;
+		pinfo = p->info;
+		prop_node_id = spa_dict_lookup(pinfo->props, PW_KEY_NODE_ID);
+		if (!prop_node_id || (uint32_t)atoi(prop_node_id) != g->id)
+			continue;
+		if (p->draw)
+			p->draw(p);
+	}
+
+	/* draw the client/factory box if all option is enabled */
+	if (g->data->show_all) {
+		dot_str_add(dot_str, "node_%u [shape=box style=filled fillcolor=white];\n", g->id);
+		dot_str_add(dot_str, "node_%u [label=\"client_id: %u\\lfactory_id: %u\\l\"];\n", g->id, client_id, factory_id);
+	}
+
+	/* draw the node footer */
+	dot_str_add(dot_str, "}\n");
+
+	/* draw the client/factory arrows if all option is enabled */
+	if (g->data->show_all) {
+		dot_str_add(dot_str, "node_%u -> client_%u [style=dashed];\n", g->id, client_id);
+		dot_str_add(dot_str, "node_%u -> factory_%u [style=dashed];\n", g->id, factory_id);
+	}
+}
+
+static void draw_link(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Link);
+
+	struct pw_link_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str, "link_%u [shape=box style=filled fillcolor=lightblue];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"link", g->id, g->data->show_detail, info->props,
+		"link_id: %u\\loutput_node_id: %u\\linput_node_id: %u\\loutput_port_id: %u\\linput_port_id: %u\\lstate: %s\\l",
+		g->id,
+		info->output_node_id,
+		info->input_node_id,
+		info->output_port_id,
+		info->input_port_id,
+		pw_link_state_as_string(info->state)
+	);
+
+	/* draw the arrows */
+	dot_str_add(dot_str, "port_%u -> link_%u -> port_%u;\n", info->output_port_id, g->id, info->input_port_id);
+}
+
+static void draw_client(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Client);
+
+	struct pw_client_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str, "client_%u [shape=box style=filled fillcolor=tan1];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"client", g->id, g->data->show_detail, info->props,
+		"client_id: %u\\lname: %s\\lpid: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_APP_NAME),
+		spa_dict_lookup(info->props, PW_KEY_APP_PROCESS_ID)
+	);
+}
+
+static void draw_device(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Device);
+
+	struct pw_device_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	const char *client_id_str = spa_dict_lookup(info->props, PW_KEY_CLIENT_ID);
+	const char *factory_id_str = spa_dict_lookup(info->props, PW_KEY_FACTORY_ID);
+	uint32_t client_id = client_id_str ? (uint32_t)atoi(client_id_str) : GLOBAL_ID_NONE;
+	uint32_t factory_id = factory_id_str ? (uint32_t)atoi(factory_id_str) : GLOBAL_ID_NONE;
+
+	/* draw the box */
+	dot_str_add(dot_str, "device_%u [shape=box style=filled fillcolor=lightpink];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"device", g->id, g->data->show_detail, info->props,
+		"device_id: %u\\lname: %s\\lmedia_class: %s\\lapi: %s\\lpath: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_DEVICE_NAME),
+		spa_dict_lookup(info->props, PW_KEY_MEDIA_CLASS),
+		spa_dict_lookup(info->props, PW_KEY_DEVICE_API),
+		spa_dict_lookup(info->props, PW_KEY_OBJECT_PATH)
+	);
+
+	/* draw the arrows */
+	dot_str_add(dot_str, "device_%u -> client_%u [style=dashed];\n", g->id, client_id);
+	dot_str_add(dot_str, "device_%u -> factory_%u [style=dashed];\n", g->id, factory_id);
+}
+
+static void draw_factory(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Factory);
+
+	struct pw_factory_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	const char *module_id_str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID);
+	uint32_t module_id = module_id_str ? (uint32_t)atoi(module_id_str) : GLOBAL_ID_NONE;
+
+	/* draw the box */
+	dot_str_add(dot_str, "factory_%u [shape=box style=filled fillcolor=lightyellow];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"factory", g->id, g->data->show_detail, info->props,
+		"factory_id: %u\\lname: %s\\lmodule_id: %u\\l",
+		g->id, info->name, module_id
+	);
+
+	/* draw the arrow */
+	dot_str_add(dot_str, "factory_%u -> module_%u [style=dashed];\n", g->id, module_id);
+}
+
+static void draw_module(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Module);
+
+	struct pw_module_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str, "module_%u [shape=box style=filled fillcolor=lightgrey];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"module", g->id, g->data->show_detail, info->props,
+		"module_id: %u\\lname: %s\\l",
+		g->id, info->name
+	);
+}
+
+static bool is_node_id_link_referenced(uint32_t id, struct spa_list *globals)
+{
+        struct global *g;
+        struct pw_link_info *info;
+        spa_list_for_each(g, globals, link) {
+                if (g->info == NULL)
+                        continue;
+                if (g->type != INTERFACE_Link)
+                        continue;
+                info = g->info;
+                if (info->input_node_id == id || info->output_node_id == id)
+                        return true;
+        }
+        return false;
+}
+
+static bool is_module_id_factory_referenced(uint32_t id, struct spa_list *globals)
+{
+        struct global *g;
+        struct pw_factory_info *info;
+        const char *module_id_str;
+        spa_list_for_each(g, globals, link) {
+                if (g->info == NULL)
+                        continue;
+                if (g->type != INTERFACE_Factory)
+                        continue;
+                info = g->info;
+                module_id_str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID);
+                if (module_id_str && (uint32_t)atoi(module_id_str) == id)
+                        return true;
+        }
+        return false;
+}
+
+static bool is_global_referenced(struct global *g)
+{
+	switch (g->type) {
+	case INTERFACE_Node:
+		return is_node_id_link_referenced(g->id, &g->data->globals);
+	case INTERFACE_Module:
+		return is_module_id_factory_referenced(g->id, &g->data->globals);
+	default:
+		break;
+	}
+
+	return true;
+}
+
+static int draw_graph(struct data *d, const char *path)
+{
+	FILE *fp;
+	struct global *g;
+
+	/* draw the header */
+	dot_str_add(&d->dot_str, "digraph pipewire {\n");
+
+	if (d->dot_rankdir) {
+		/* set rank direction, if provided */
+		dot_str_add(&d->dot_str, "rankdir = \"%s\";\n", d->dot_rankdir);
+	}
+
+	if (d->dot_orthoedges) {
+		/* enable orthogonal edges */
+		dot_str_add(&d->dot_str, "splines = ortho;\n");
+	}
+
+	/* iterate the globals */
+	spa_list_for_each(g, &d->globals, link) {
+		/* skip null and non-info globals */
+		if (g->info == NULL)
+			continue;
+
+		/* always skip ports since they are drawn by the nodes */
+		if (g->type == INTERFACE_Port)
+			continue;
+
+		/* skip clients, devices, factories and modules if all option is disabled */
+		if (!d->show_all) {
+			switch (g->type) {
+				case INTERFACE_Client:
+				case INTERFACE_Device:
+				case INTERFACE_Factory:
+				case INTERFACE_Module:
+					continue;
+				default:
+					break;
+			}
+		}
+
+		/* skip not referenced globals if smart option is enabled */
+		if (d->show_smart && !is_global_referenced(g))
+			continue;
+
+		/* draw the global */
+		if (g->draw)
+			g->draw(g);
+	}
+
+	/* draw the footer */
+	dot_str_add(&d->dot_str, "}\n");
+
+	if (spa_streq(path, "-")) {
+		/* wire the dot graph into to stdout */
+		fputs(d->dot_str, stdout);
+	} else {
+		/* open the file */
+		fp = fopen(path, "we");
+		if (fp == NULL) {
+			printf("open error: could not open %s for writing\n", path);
+			return -1;
+		}
+
+		/* wire the dot graph into the file */
+		fputs(d->dot_str, fp);
+		fclose(fp);
+	}
+	return 0;
+}
+
+static void global_event_info(struct global *g, const void *info)
+{
+        if (g->info_update)
+                g->info = g->info_update(g->info, info);
+}
+
+static void port_event_info(void *data, const struct pw_port_info *info)
+{
+        global_event_info(data, info);
+}
+
+static const struct pw_port_events port_events = {
+        PW_VERSION_PORT_EVENTS,
+        .info = port_event_info,
+};
+
+static void node_event_info(void *data, const struct pw_node_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_node_events node_events = {
+	PW_VERSION_NODE_EVENTS,
+	.info = node_event_info,
+};
+
+static void link_event_info(void *data, const struct pw_link_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_link_events link_events = {
+	PW_VERSION_LINK_EVENTS,
+	.info = link_event_info
+};
+
+static void client_event_info(void *data, const struct pw_client_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_client_events client_events = {
+	PW_VERSION_CLIENT_EVENTS,
+	.info = client_event_info
+};
+
+static void device_event_info(void *data, const struct pw_device_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_device_events device_events = {
+	PW_VERSION_DEVICE_EVENTS,
+	.info = device_event_info
+};
+
+static void factory_event_info(void *data, const struct pw_factory_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_factory_events factory_events = {
+	PW_VERSION_FACTORY_EVENTS,
+	.info = factory_event_info
+};
+
+static void module_event_info(void *data, const struct pw_module_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_module_events module_events = {
+	PW_VERSION_MODULE_EVENTS,
+	.info = module_event_info
+};
+
+static void removed_proxy(void *data)
+{
+	struct global *g = data;
+	pw_proxy_destroy(g->proxy);
+}
+
+static void destroy_proxy(void *data)
+{
+	struct global *g = data;
+	spa_hook_remove(&g->object_listener);
+	spa_hook_remove(&g->proxy_listener);
+}
+
+static const struct pw_proxy_events proxy_events = {
+	PW_VERSION_PROXY_EVENTS,
+	.removed = removed_proxy,
+	.destroy = destroy_proxy,
+};
+
+static void registry_event_global(void *data, uint32_t id, uint32_t permissions,
+				  const char *type, uint32_t version,
+				  const struct spa_dict *props)
+{
+        struct data *d = data;
+        struct pw_proxy *proxy;
+        uint32_t client_version;
+	uint32_t object_type;
+        const void *events;
+        pw_destroy_t info_destroy;
+        info_update_t info_update;
+        draw_t draw;
+        struct global *g;
+
+	if (spa_streq(type, PW_TYPE_INTERFACE_Port)) {
+		events = &port_events;
+		info_destroy = (pw_destroy_t)pw_port_info_free;
+		info_update = (info_update_t)pw_port_info_update;
+		draw = draw_port;
+		client_version = PW_VERSION_PORT;
+		object_type = INTERFACE_Port;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Node)) {
+		events = &node_events;
+		info_destroy = (pw_destroy_t)pw_node_info_free;
+		info_update = (info_update_t)pw_node_info_update;
+		draw = draw_node;
+		client_version = PW_VERSION_NODE;
+		object_type = INTERFACE_Node;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Link)) {
+		events = &link_events;
+		info_destroy = (pw_destroy_t)pw_link_info_free;
+		info_update = (info_update_t)pw_link_info_update;
+		draw = draw_link;
+		client_version = PW_VERSION_LINK;
+		object_type = INTERFACE_Link;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Client)) {
+		events = &client_events;
+		info_destroy = (pw_destroy_t)pw_client_info_free;
+		info_update = (info_update_t)pw_client_info_update;
+		draw = draw_client;
+		client_version = PW_VERSION_CLIENT;
+		object_type = INTERFACE_Client;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Device)) {
+		events = &device_events;
+		info_destroy = (pw_destroy_t)pw_device_info_free;
+		info_update = (info_update_t)pw_device_info_update;
+		draw = draw_device;
+		client_version = PW_VERSION_DEVICE;
+		object_type = INTERFACE_Device;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Factory)) {
+		events = &factory_events;
+		info_destroy = (pw_destroy_t)pw_factory_info_free;
+		info_update = (info_update_t)pw_factory_info_update;
+		draw = draw_factory;
+		client_version = PW_VERSION_FACTORY;
+		object_type = INTERFACE_Factory;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Module)) {
+		events = &module_events;
+		info_destroy = (pw_destroy_t)pw_module_info_free;
+		info_update = (info_update_t)pw_module_info_update;
+		draw = draw_module;
+		client_version = PW_VERSION_MODULE;
+		object_type = INTERFACE_Module;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Core)) {
+		/* sync to notify we are done with globals */
+		pw_core_sync(d->core, 0, 0);
+		return;
+	}
+	else {
+		return;
+	}
+
+	proxy = pw_registry_bind(d->registry, id, type, client_version, 0);
+	if (proxy == NULL)
+		return;
+
+	/* set the global data */
+	g = calloc(1, sizeof(struct global));
+	g->data = d;
+	g->proxy = proxy;
+
+	g->id = id;
+	g->type = object_type;
+	g->info = NULL;
+
+	g->info_destroy = info_destroy;
+	g->info_update = info_update;
+	g->draw = draw;
+
+        pw_proxy_add_object_listener(proxy, &g->object_listener, events, g);
+        pw_proxy_add_listener(proxy, &g->proxy_listener, &proxy_events, g);
+
+        /* add the global to the list */
+        spa_list_insert(&d->globals, &g->link);
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+};
+
+static void on_core_done(void *data, uint32_t id, int seq)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
+{
+	struct 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)
+		pw_main_loop_quit(d->loop);
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.done = on_core_done,
+	.error = on_core_error,
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static int get_data_from_pipewire(struct data *data, const char *opt_remote)
+{
+	struct pw_loop *l;
+	struct global *g;
+
+	data->loop = pw_main_loop_new(NULL);
+	if (data->loop == NULL) {
+		fprintf(stderr, "can't create main loop: %m\n");
+		return -1;
+	}
+
+	l = pw_main_loop_get_loop(data->loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data->context = pw_context_new(l, NULL, 0);
+	if (data->context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		pw_main_loop_destroy(data->loop);
+		return -1;
+	}
+
+	data->core = pw_context_connect(data->context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, opt_remote,
+				NULL),
+			0);
+	if (data->core == NULL) {
+		fprintf(stderr, "can't connect: %m\n");
+		pw_context_destroy(data->context);
+		pw_main_loop_destroy(data->loop);
+		return -1;
+	}
+
+	pw_core_add_listener(data->core,
+			     &data->core_listener,
+			     &core_events, data);
+
+	data->registry = pw_core_get_registry(data->core,
+					      PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data->registry,
+				 &data->registry_listener,
+				 &registry_events, data);
+
+	pw_main_loop_run(data->loop);
+
+	spa_hook_remove(&data->registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data->registry);
+	spa_list_for_each(g, &data->globals, link)
+		pw_proxy_destroy(g->proxy);
+	spa_hook_remove(&data->core_listener);
+	pw_context_destroy(data->context);
+	pw_main_loop_destroy(data->loop);
+
+	return 0;
+}
+
+static void handle_json_obj(struct data *data, struct pw_properties *obj)
+{
+	struct global *g;
+	struct pw_properties *info, *props;
+	const char *str;
+
+	str = pw_properties_get(obj, "type");
+	if (!str) {
+		fprintf(stderr, "invalid object without type\n");
+		return;
+	}
+
+	g = calloc(1, sizeof (struct global));
+	g->data = data;
+
+	if (spa_streq(str, PW_TYPE_INTERFACE_Port)) {
+		g->info_destroy = (pw_destroy_t)pw_port_info_free;
+		g->draw = draw_port;
+		g->type = INTERFACE_Port;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Node)) {
+		g->info_destroy = (pw_destroy_t)pw_node_info_free;
+		g->draw = draw_node;
+		g->type = INTERFACE_Node;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Link)) {
+		g->info_destroy = (pw_destroy_t)pw_link_info_free;
+		g->draw = draw_link;
+		g->type = INTERFACE_Link;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Client)) {
+		g->info_destroy = (pw_destroy_t)pw_client_info_free;
+		g->draw = draw_client;
+		g->type = INTERFACE_Client;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Device)) {
+		g->info_destroy = (pw_destroy_t)pw_device_info_free;
+		g->draw = draw_device;
+		g->type = INTERFACE_Device;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Factory)) {
+		g->info_destroy = (pw_destroy_t)pw_factory_info_free;
+		g->draw = draw_factory;
+		g->type = INTERFACE_Factory;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Module)) {
+		g->info_destroy = (pw_destroy_t)pw_module_info_free;
+		g->draw = draw_module;
+		g->type = INTERFACE_Module;
+	}
+	else {
+		free(g);
+		return;
+	}
+
+	g->id = pw_properties_get_uint32(obj, "id", 0);
+
+	str = pw_properties_get(obj, "info");
+	info = pw_properties_new_string(str);
+
+	str = pw_properties_get(info, "props");
+	props = str ? pw_properties_new_string(str) : NULL;
+
+	switch (g->type) {
+		case INTERFACE_Port: {
+			struct pw_port_info pinfo = {0};
+			pinfo.id = g->id;
+			str = pw_properties_get(info, "direction");
+			pinfo.direction = spa_streq(str, "output") ?
+				PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT;
+			pinfo.props = props ? &props->dict : NULL;
+			pinfo.change_mask = PW_PORT_CHANGE_MASK_PROPS;
+			g->info = pw_port_info_update(NULL, &pinfo);
+			break;
+		}
+		case INTERFACE_Node: {
+			struct pw_node_info ninfo = {0};
+			ninfo.id = g->id;
+			ninfo.max_input_ports =
+				pw_properties_get_uint32(info, "max-input-ports", 0);
+			ninfo.max_output_ports =
+				pw_properties_get_uint32(info, "max-output-ports", 0);
+			ninfo.n_input_ports =
+				pw_properties_get_uint32(info, "n-input-ports", 0);
+			ninfo.n_output_ports =
+				pw_properties_get_uint32(info, "n-output-ports", 0);
+
+			str = pw_properties_get(info, "state");
+			if (spa_streq(str, "running"))
+				ninfo.state = PW_NODE_STATE_RUNNING;
+			else if (spa_streq(str, "idle"))
+				ninfo.state = PW_NODE_STATE_IDLE;
+			else if (spa_streq(str, "suspended"))
+				ninfo.state = PW_NODE_STATE_SUSPENDED;
+			else if (spa_streq(str, "creating"))
+				ninfo.state = PW_NODE_STATE_CREATING;
+			else
+				ninfo.state = PW_NODE_STATE_ERROR;
+			ninfo.error = pw_properties_get(info, "error");
+
+			ninfo.props = props ? &props->dict : NULL;
+			ninfo.change_mask = PW_NODE_CHANGE_MASK_INPUT_PORTS |
+					    PW_NODE_CHANGE_MASK_OUTPUT_PORTS |
+					    PW_NODE_CHANGE_MASK_STATE |
+					    PW_NODE_CHANGE_MASK_PROPS;
+			g->info = pw_node_info_update(NULL, &ninfo);
+			break;
+		}
+		case INTERFACE_Link: {
+			struct pw_link_info linfo = {0};
+			linfo.id = g->id;
+			linfo.output_node_id =
+				pw_properties_get_uint32(info, "output-node-id", 0);
+			linfo.output_port_id =
+				pw_properties_get_uint32(info, "output-port-id", 0);
+			linfo.input_node_id =
+				pw_properties_get_uint32(info, "input-node-id", 0);
+			linfo.input_port_id =
+				pw_properties_get_uint32(info, "input-port-id", 0);
+
+			str = pw_properties_get(info, "state");
+			if (spa_streq(str, "active"))
+				linfo.state = PW_LINK_STATE_ACTIVE;
+			else if (spa_streq(str, "paused"))
+				linfo.state = PW_LINK_STATE_PAUSED;
+			else if (spa_streq(str, "allocating"))
+				linfo.state = PW_LINK_STATE_ALLOCATING;
+			else if (spa_streq(str, "negotiating"))
+				linfo.state = PW_LINK_STATE_NEGOTIATING;
+			else if (spa_streq(str, "init"))
+				linfo.state = PW_LINK_STATE_INIT;
+			else if (spa_streq(str, "unlinked"))
+				linfo.state = PW_LINK_STATE_UNLINKED;
+			else
+				linfo.state = PW_LINK_STATE_ERROR;
+			linfo.error = pw_properties_get(info, "error");
+
+			linfo.props = props ? &props->dict : NULL;
+			linfo.change_mask = PW_LINK_CHANGE_MASK_STATE |
+					    PW_LINK_CHANGE_MASK_PROPS;
+			g->info = pw_link_info_update(NULL, &linfo);
+			break;
+		}
+		case INTERFACE_Client: {
+			struct pw_client_info cinfo = {0};
+			cinfo.id = g->id;
+			cinfo.props = props ? &props->dict : NULL;
+			cinfo.change_mask = PW_CLIENT_CHANGE_MASK_PROPS;
+			g->info = pw_client_info_update(NULL, &cinfo);
+			break;
+		}
+		case INTERFACE_Device: {
+			struct pw_device_info dinfo = {0};
+			dinfo.id = g->id;
+			dinfo.props = props ? &props->dict : NULL;
+			dinfo.change_mask = PW_DEVICE_CHANGE_MASK_PROPS;
+			g->info = pw_device_info_update(NULL, &dinfo);
+			break;
+		}
+		case INTERFACE_Factory: {
+			struct pw_factory_info finfo = {0};
+			finfo.id = g->id;
+			finfo.name = pw_properties_get(info, "name");
+			finfo.type = pw_properties_get(info, "type");
+			finfo.version = pw_properties_get_uint32(info, "version", 0);
+			finfo.props = props ? &props->dict : NULL;
+			finfo.change_mask = PW_FACTORY_CHANGE_MASK_PROPS;
+			g->info = pw_factory_info_update(NULL, &finfo);
+			break;
+		}
+		case INTERFACE_Module: {
+			struct pw_module_info minfo = {0};
+			minfo.id = g->id;
+			minfo.name = pw_properties_get(info, "name");
+			minfo.filename = pw_properties_get(info, "filename");
+			minfo.args = pw_properties_get(info, "args");
+			minfo.props = props ? &props->dict : NULL;
+			minfo.change_mask = PW_MODULE_CHANGE_MASK_PROPS;
+			g->info = pw_module_info_update(NULL, &minfo);
+			break;
+		}
+		default:
+			break;
+	}
+
+	pw_properties_free(info);
+	pw_properties_free(props);
+
+	/* add the global to the list */
+	spa_list_insert(&data->globals, &g->link);
+}
+
+static int get_data_from_json(struct data *data, const char *json_path)
+{
+	int fd, len;
+	void *json;
+	struct stat sbuf;
+	struct spa_json it[2];
+	const char *value;
+
+	if ((fd = open(json_path,  O_CLOEXEC | O_RDONLY)) < 0) {
+		fprintf(stderr, "error opening file '%s': %m\n", json_path);
+		return -1;
+	}
+	if (fstat(fd, &sbuf) < 0) {
+		fprintf(stderr, "error statting file '%s': %m\n", json_path);
+		close(fd);
+		return -1;
+	}
+	if ((json = mmap(NULL, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) {
+		fprintf(stderr, "error mmapping file '%s': %m\n", json_path);
+		close(fd);
+		return -1;
+	}
+
+	close(fd);
+	spa_json_init(&it[0], json, sbuf.st_size);
+
+	if (spa_json_enter_array(&it[0], &it[1]) <= 0) {
+		fprintf(stderr, "expected top-level array in JSON file '%s'\n", json_path);
+		munmap(json, sbuf.st_size);
+		return -1;
+	}
+
+	while ((len = spa_json_next(&it[1], &value)) > 0 && spa_json_is_object(value, len)) {
+		struct pw_properties *obj;
+		obj = pw_properties_new(NULL, NULL);
+		len = spa_json_container_len(&it[1], value, len);
+		pw_properties_update_string(obj, value, len);
+		handle_json_obj(data, obj);
+		pw_properties_free(obj);
+	}
+
+	munmap(json, sbuf.st_size);
+	return 0;
+}
+
+static void show_help(const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -a, --all                             Show all object types\n"
+		"  -s, --smart                           Show linked objects only\n"
+		"  -d, --detail                          Show all object properties\n"
+		"  -r, --remote                          Remote daemon name\n"
+		"  -o, --output                          Output file (Default %s)\n"
+		"  -L, --lr                              Use left-right rank direction\n"
+		"  -9, --90                              Use orthogonal edges\n"
+		"  -j, --json                            Read objects from pw-dump JSON file\n",
+		name,
+		DEFAULT_DOT_PATH);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct global *g;
+	const char *opt_remote = NULL;
+	const char *dot_path = DEFAULT_DOT_PATH;
+	const char *json_path = NULL;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "all",	no_argument,		NULL, 'a' },
+		{ "smart",	no_argument,		NULL, 's' },
+		{ "detail",	no_argument,		NULL, 'd' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ "output",	required_argument,	NULL, 'o' },
+		{ "lr",		no_argument,		NULL, 'L' },
+		{ "90",		no_argument,		NULL, '9' },
+		{ "json",	required_argument,	NULL, 'j' },
+		{ NULL, 0, NULL, 0}
+	};
+	int c;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	while ((c = getopt_long(argc, argv, "hVasdr:o:L9j:", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h' :
+			show_help(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 'a' :
+			data.show_all = true;
+			fprintf(stderr, "all option enabled\n");
+			break;
+		case 's' :
+			data.show_smart = true;
+			fprintf(stderr, "smart option enabled\n");
+			break;
+		case 'd' :
+			data.show_detail = true;
+			fprintf(stderr, "detail option enabled\n");
+			break;
+		case 'r' :
+			opt_remote = optarg;
+			fprintf(stderr, "set remote to %s\n", opt_remote);
+			break;
+		case 'o' :
+			dot_path = optarg;
+			fprintf(stderr, "set output file %s\n", dot_path);
+			break;
+		case 'L' :
+			data.dot_rankdir = "LR";
+			fprintf(stderr, "set rank direction to LR\n");
+			break;
+		case '9' :
+			data.dot_orthoedges = true;
+			fprintf(stderr, "orthogonal edges enabled\n");
+			break;
+		case 'j' :
+			json_path = optarg;
+			fprintf(stderr, "Using JSON file %s as input\n", json_path);
+			break;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+
+	if (!(data.dot_str = dot_str_new()))
+		return -1;
+
+	spa_list_init(&data.globals);
+
+	if (!json_path && get_data_from_pipewire(&data, opt_remote) < 0)
+		return -1;
+	else if (json_path && get_data_from_json(&data, json_path) < 0)
+		return -1;
+
+	draw_graph(&data, dot_path);
+
+	dot_str_clear(&data.dot_str);
+	spa_list_consume(g, &data.globals, link) {
+		if (g->info && g->info_destroy)
+			g->info_destroy(g->info);
+		spa_list_remove(&g->link);
+		free(g);
+	}
+	pw_deinit();
+
+	return 0;
+}
diff --git a/src/tools/pw-dump.c b/src/tools/pw-dump.c
new file mode 100644
index 0000000..ecc2c55
--- /dev/null
+++ b/src/tools/pw-dump.c
@@ -0,0 +1,1664 @@
+/* PipeWire
+ *
+ * Copyright © 2020 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * 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 <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <getopt.h>
+#include <limits.h>
+#include <math.h>
+#include <fnmatch.h>
+#include <locale.h>
+
+#if !defined(FNM_EXTMATCH)
+#define FNM_EXTMATCH 0
+#endif
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/pod/iter.h>
+#include <spa/debug/types.h>
+#include <spa/utils/json.h>
+#include <spa/utils/ansi.h>
+#include <spa/utils/string.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/extensions/metadata.h>
+
+#define INDENT 2
+
+static bool colors = false;
+
+#define NORMAL	(colors ? SPA_ANSI_RESET : "")
+#define LITERAL	(colors ? SPA_ANSI_BRIGHT_MAGENTA : "")
+#define NUMBER	(colors ? SPA_ANSI_BRIGHT_CYAN : "")
+#define STRING	(colors ? SPA_ANSI_BRIGHT_GREEN : "")
+#define KEY	(colors ? SPA_ANSI_BRIGHT_BLUE : "")
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	struct pw_core_info *info;
+	struct pw_core *core;
+	struct spa_hook core_listener;
+	int sync_seq;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct spa_list object_list;
+
+	const char *pattern;
+
+	FILE *out;
+	int level;
+#define STATE_KEY	(1<<0)
+#define STATE_COMMA	(1<<1)
+#define STATE_FIRST	(1<<2)
+#define STATE_MASK	0xffff0000
+#define STATE_SIMPLE	(1<<16)
+	uint32_t state;
+
+	unsigned int monitor:1;
+};
+
+struct param {
+	uint32_t id;
+	int32_t seq;
+	struct spa_list link;
+	struct spa_pod *param;
+};
+
+struct object;
+
+struct class {
+	const char *type;
+	uint32_t version;
+	const void *events;
+	void (*destroy) (struct object *object);
+	void (*dump) (struct object *object);
+	const char *name_key;
+};
+
+struct object {
+	struct spa_list link;
+
+	struct data *data;
+
+	uint32_t id;
+	uint32_t permissions;
+	char *type;
+	uint32_t version;
+	struct pw_properties *props;
+
+	const struct class *class;
+	void *info;
+	struct spa_param_info *params;
+	uint32_t n_params;
+
+	int changed;
+	struct spa_list param_list;
+	struct spa_list pending_list;
+	struct spa_list data_list;
+
+	struct pw_proxy *proxy;
+	struct spa_hook proxy_listener;
+	struct spa_hook object_listener;
+};
+
+static void core_sync(struct data *d)
+{
+	d->sync_seq = pw_core_sync(d->core, PW_ID_CORE, d->sync_seq);
+	pw_log_debug("sync start %u", d->sync_seq);
+}
+
+static uint32_t clear_params(struct spa_list *param_list, uint32_t id)
+{
+	struct param *p, *t;
+	uint32_t count = 0;
+
+	spa_list_for_each_safe(p, t, param_list, link) {
+		if (id == SPA_ID_INVALID || p->id == id) {
+			spa_list_remove(&p->link);
+			free(p);
+			count++;
+		}
+	}
+	return count;
+}
+
+static struct param *add_param(struct spa_list *params, int seq,
+		uint32_t id, const struct spa_pod *param)
+{
+	struct param *p;
+
+	if (id == SPA_ID_INVALID) {
+		if (param == NULL || !spa_pod_is_object(param)) {
+			errno = EINVAL;
+			return NULL;
+		}
+		id = SPA_POD_OBJECT_ID(param);
+	}
+
+	p = malloc(sizeof(*p) + (param != NULL ? SPA_POD_SIZE(param) : 0));
+	if (p == NULL)
+		return NULL;
+
+	p->id = id;
+	p->seq = seq;
+	if (param != NULL) {
+		p->param = SPA_PTROFF(p, sizeof(*p), struct spa_pod);
+		memcpy(p->param, param, SPA_POD_SIZE(param));
+	} else {
+		clear_params(params, id);
+		p->param = NULL;
+	}
+	spa_list_append(params, &p->link);
+
+	return p;
+}
+
+static struct object *find_object(struct data *d, uint32_t id)
+{
+	struct object *o;
+	spa_list_for_each(o, &d->object_list, link) {
+		if (o->id == id)
+			return o;
+	}
+	return NULL;
+}
+
+static void object_update_params(struct spa_list *param_list, struct spa_list *pending_list,
+		uint32_t n_params, struct spa_param_info *params)
+{
+	struct param *p, *t;
+	uint32_t i;
+
+	for (i = 0; i < n_params; i++) {
+		spa_list_for_each_safe(p, t, pending_list, link) {
+			if (p->id == params[i].id &&
+			    p->seq != params[i].seq &&
+			    p->param != NULL) {
+				spa_list_remove(&p->link);
+				free(p);
+			}
+		}
+	}
+
+	spa_list_consume(p, pending_list, link) {
+		spa_list_remove(&p->link);
+		if (p->param == NULL) {
+			clear_params(param_list, p->id);
+			free(p);
+		} else {
+			spa_list_append(param_list, &p->link);
+		}
+	}
+}
+
+static void object_destroy(struct object *o)
+{
+	spa_list_remove(&o->link);
+	if (o->proxy)
+		pw_proxy_destroy(o->proxy);
+	pw_properties_free(o->props);
+	clear_params(&o->param_list, SPA_ID_INVALID);
+	clear_params(&o->pending_list, SPA_ID_INVALID);
+	free(o->type);
+	free(o);
+}
+
+static void put_key(struct data *d, const char *key);
+
+static SPA_PRINTF_FUNC(3,4) void put_fmt(struct data *d, const char *key, const char *fmt, ...)
+{
+	va_list va;
+	if (key)
+		put_key(d, key);
+	fprintf(d->out, "%s%s%*s",
+			d->state & STATE_COMMA ? "," : "",
+			d->state & (STATE_MASK | STATE_KEY) ? " " : d->state & STATE_FIRST ? "" : "\n",
+			d->state & (STATE_MASK | STATE_KEY) ? 0 : d->level, "");
+	va_start(va, fmt);
+	vfprintf(d->out, fmt, va);
+	va_end(va);
+	d->state = (d->state & STATE_MASK) + STATE_COMMA;
+}
+
+static void put_key(struct data *d, const char *key)
+{
+	int size = (strlen(key) + 1) * 4;
+	char *str = alloca(size);
+	spa_json_encode_string(str, size, key);
+	put_fmt(d, NULL, "%s%s%s:", KEY, str, NORMAL);
+	d->state = (d->state & STATE_MASK) + STATE_KEY;
+}
+
+static void put_begin(struct data *d, const char *key, const char *type, uint32_t flags)
+{
+	put_fmt(d, key, "%s", type);
+	d->level += INDENT;
+	d->state = (d->state & STATE_MASK) + (flags & STATE_SIMPLE);
+}
+
+static void put_end(struct data *d, const char *type, uint32_t flags)
+{
+	d->level -= INDENT;
+	d->state = d->state & STATE_MASK;
+	put_fmt(d, NULL, "%s", type);
+	d->state = (d->state & STATE_MASK) + STATE_COMMA - (flags & STATE_SIMPLE);
+}
+
+static void put_encoded_string(struct data *d, const char *key, const char *val)
+{
+	put_fmt(d, key, "%s%s%s", STRING, val, NORMAL);
+}
+static void put_string(struct data *d, const char *key, const char *val)
+{
+	int size = (strlen(val) + 1) * 4;
+	char *str = alloca(size);
+	spa_json_encode_string(str, size, val);
+	put_encoded_string(d, key, str);
+}
+
+static void put_literal(struct data *d, const char *key, const char *val)
+{
+	put_fmt(d, key, "%s%s%s", LITERAL, val, NORMAL);
+}
+
+static void put_int(struct data *d, const char *key, int64_t val)
+{
+	put_fmt(d, key, "%s%"PRIi64"%s", NUMBER, val, NORMAL);
+}
+
+static void put_double(struct data *d, const char *key, double val)
+{
+	char buf[128];
+	put_fmt(d, key, "%s%s%s", NUMBER,
+			spa_json_format_float(buf, sizeof(buf), val), NORMAL);
+}
+
+static void put_value(struct data *d, const char *key, const char *val)
+{
+	int64_t li;
+	float fv;
+
+	if (val == NULL)
+		put_literal(d, key, "null");
+	else if (spa_streq(val, "true") || spa_streq(val, "false"))
+		put_literal(d, key, val);
+	else if (spa_atoi64(val, &li, 10))
+		put_int(d, key, li);
+	else if (spa_json_parse_float(val, strlen(val), &fv))
+		put_double(d, key, fv);
+	else
+		put_string(d, key, val);
+}
+
+static void put_dict(struct data *d, const char *key, struct spa_dict *dict)
+{
+	const struct spa_dict_item *it;
+	spa_dict_qsort(dict);
+	put_begin(d, key, "{", 0);
+	spa_dict_for_each(it, dict)
+		put_value(d, it->key, it->value);
+	put_end(d, "}", 0);
+}
+
+static void put_pod_value(struct data *d, const char *key, const struct spa_type_info *info,
+		uint32_t type, void *body, uint32_t size)
+{
+	if (key)
+		put_key(d, key);
+	switch (type) {
+	case SPA_TYPE_Bool:
+		put_value(d, NULL, *(int32_t*)body ? "true" : "false");
+		break;
+	case SPA_TYPE_Id:
+	{
+		const char *str;
+		char fallback[32];
+		uint32_t id = *(uint32_t*)body;
+		str = spa_debug_type_find_short_name(info, *(uint32_t*)body);
+		if (str == NULL) {
+			snprintf(fallback, sizeof(fallback), "id-%08x", id);
+			str = fallback;
+		}
+		put_value(d, NULL, str);
+		break;
+	}
+	case SPA_TYPE_Int:
+		put_int(d, NULL, *(int32_t*)body);
+		break;
+	case SPA_TYPE_Fd:
+	case SPA_TYPE_Long:
+		put_int(d, NULL, *(int64_t*)body);
+		break;
+	case SPA_TYPE_Float:
+		put_double(d, NULL, *(float*)body);
+		break;
+	case SPA_TYPE_Double:
+		put_double(d, NULL, *(double*)body);
+		break;
+	case SPA_TYPE_String:
+		put_string(d, NULL, (const char*)body);
+		break;
+	case SPA_TYPE_Rectangle:
+	{
+                struct spa_rectangle *r = (struct spa_rectangle *)body;
+		put_begin(d, NULL, "{", STATE_SIMPLE);
+		put_int(d, "width", r->width);
+		put_int(d, "height", r->height);
+		put_end(d, "}", STATE_SIMPLE);
+		break;
+	}
+	case SPA_TYPE_Fraction:
+	{
+                struct spa_fraction *f = (struct spa_fraction *)body;
+		put_begin(d, NULL, "{", STATE_SIMPLE);
+		put_int(d, "num", f->num);
+		put_int(d, "denom", f->denom);
+		put_end(d, "}", STATE_SIMPLE);
+		break;
+	}
+	case SPA_TYPE_Array:
+	{
+		struct spa_pod_array_body *b = (struct spa_pod_array_body *)body;
+		void *p;
+		info = info && info->values ? info->values: info;
+		put_begin(d, NULL, "[", STATE_SIMPLE);
+		SPA_POD_ARRAY_BODY_FOREACH(b, size, p)
+			put_pod_value(d, NULL, info, b->child.type, p, b->child.size);
+		put_end(d, "]", STATE_SIMPLE);
+		break;
+	}
+	case SPA_TYPE_Choice:
+	{
+		struct spa_pod_choice_body *b = (struct spa_pod_choice_body *)body;
+		int index = 0;
+
+		if (b->type == SPA_CHOICE_None) {
+			put_pod_value(d, NULL, info, b->child.type,
+					SPA_POD_CONTENTS(struct spa_pod, &b->child),
+					b->child.size);
+		} else {
+			static const char * const range_labels[] = { "default", "min", "max", NULL };
+			static const char * const step_labels[] = { "default", "min", "max", "step", NULL };
+			static const char * const enum_labels[] = { "default", "alt%u" };
+			static const char * const flags_labels[] = { "default", "flag%u" };
+
+			const char * const *labels;
+			const char *label;
+			char buffer[64];
+			int max_labels, flags = 0;
+			void *p;
+
+			switch (b->type) {
+			case SPA_CHOICE_Range:
+				labels = range_labels;
+				max_labels = 3;
+				flags |= STATE_SIMPLE;
+				break;
+			case SPA_CHOICE_Step:
+				labels = step_labels;
+				max_labels = 4;
+				flags |= STATE_SIMPLE;
+				break;
+			case SPA_CHOICE_Enum:
+				labels = enum_labels;
+				max_labels = 1;
+				break;
+			case SPA_CHOICE_Flags:
+				labels = flags_labels;
+				max_labels = 1;
+				break;
+			default:
+				labels = NULL;
+				break;
+			}
+			if (labels == NULL)
+				break;
+
+			put_begin(d, NULL, "{", flags);
+			SPA_POD_CHOICE_BODY_FOREACH(b, size, p) {
+				if ((label = labels[SPA_CLAMP(index, 0, max_labels)]) == NULL)
+					break;
+				snprintf(buffer, sizeof(buffer), label, index);
+				put_pod_value(d, buffer, info, b->child.type, p, b->child.size);
+				index++;
+			}
+			put_end(d, "}", flags);
+		}
+		break;
+	}
+	case SPA_TYPE_Object:
+        {
+		put_begin(d, NULL, "{", 0);
+		struct spa_pod_object_body *b = (struct spa_pod_object_body *)body;
+		struct spa_pod_prop *p;
+		const struct spa_type_info *ti, *ii;
+
+		ti = spa_debug_type_find(info, b->type);
+		ii = ti ? spa_debug_type_find(ti->values, 0) : NULL;
+		ii = ii ? spa_debug_type_find(ii->values, b->id) : NULL;
+
+		info = ti ? ti->values : info;
+
+		SPA_POD_OBJECT_BODY_FOREACH(b, size, p) {
+			char fallback[32];
+			const char *name;
+
+			ii = spa_debug_type_find(info, p->key);
+			name = ii ? spa_debug_type_short_name(ii->name) : NULL;
+			if (name == NULL) {
+				snprintf(fallback, sizeof(fallback), "id-%08x", p->key);
+				name = fallback;
+			}
+			put_pod_value(d, name,
+					ii ? ii->values : NULL,
+					p->value.type,
+					SPA_POD_CONTENTS(struct spa_pod_prop, p),
+					p->value.size);
+		}
+		put_end(d, "}", 0);
+		break;
+	}
+	case SPA_TYPE_Struct:
+	{
+		struct spa_pod *b = (struct spa_pod *)body, *p;
+		put_begin(d, NULL, "[", 0);
+		SPA_POD_FOREACH(b, size, p)
+			put_pod_value(d, NULL, info, p->type, SPA_POD_BODY(p), p->size);
+		put_end(d, "]", 0);
+		break;
+	}
+	case SPA_TYPE_None:
+		put_value(d, NULL, NULL);
+		break;
+	}
+}
+static void put_pod(struct data *d, const char *key, const struct spa_pod *pod)
+{
+	if (pod == NULL) {
+		put_value(d, key, NULL);
+	} else {
+		put_pod_value(d, key, SPA_TYPE_ROOT,
+				SPA_POD_TYPE(pod),
+				SPA_POD_BODY(pod),
+				SPA_POD_BODY_SIZE(pod));
+	}
+}
+
+static void put_params(struct data *d, const char *key,
+		struct spa_param_info *params, uint32_t n_params,
+		struct spa_list *list)
+{
+	uint32_t i;
+
+	put_begin(d, key, "{", 0);
+	for (i = 0; i < n_params; i++) {
+		struct spa_param_info *pi = &params[i];
+		struct param *p;
+		uint32_t flags;
+
+		flags = pi->flags & SPA_PARAM_INFO_READ ? 0 : STATE_SIMPLE;
+
+		put_begin(d, spa_debug_type_find_short_name(spa_type_param, pi->id),
+				"[", flags);
+		spa_list_for_each(p, list, link) {
+			if (p->id == pi->id)
+				put_pod(d, NULL, p->param);
+		}
+		put_end(d, "]", flags);
+	}
+	put_end(d, "}", 0);
+}
+
+struct flags_info {
+	const char *name;
+	uint64_t mask;
+};
+
+static void put_flags(struct data *d, const char *key,
+		uint64_t flags, const struct flags_info *info)
+{
+	uint32_t i;
+	put_begin(d, key, "[", STATE_SIMPLE);
+	for (i = 0; info[i].name != NULL; i++) {
+		if (info[i].mask & flags)
+			put_string(d, NULL, info[i].name);
+	}
+	put_end(d, "]", STATE_SIMPLE);
+}
+
+/* core */
+static void core_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "props", PW_CORE_CHANGE_MASK_PROPS },
+		{ NULL, 0 },
+	};
+
+	struct data *d = o->data;
+	struct pw_core_info *i = d->info;
+
+	put_begin(d, "info", "{", 0);
+	put_int(d, "cookie", i->cookie);
+	put_value(d, "user-name", i->user_name);
+	put_value(d, "host-name", i->host_name);
+	put_value(d, "version", i->version);
+	put_value(d, "name", i->name);
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_dict(d, "props", i->props);
+	put_end(d, "}", 0);
+}
+
+static const struct class core_class = {
+	.type = PW_TYPE_INTERFACE_Core,
+	.version = PW_VERSION_CORE,
+	.dump = core_dump,
+	.name_key = PW_KEY_CORE_NAME,
+};
+
+/* client */
+static void client_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "props", PW_CLIENT_CHANGE_MASK_PROPS },
+		{ NULL, 0 },
+	};
+
+	struct data *d = o->data;
+	struct pw_client_info *i = o->info;
+
+	put_begin(d, "info", "{", 0);
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_dict(d, "props", i->props);
+	put_end(d, "}", 0);
+}
+
+static void client_event_info(void *data, const struct pw_client_info *info)
+{
+	struct object *o = data;
+	int changed = 0;
+
+	pw_log_debug("object %p: id:%d change-mask:%08"PRIx64, o, o->id, info->change_mask);
+
+	info = o->info = pw_client_info_update(o->info, info);
+	if (info == NULL)
+		return;
+
+	if (info->change_mask & PW_CLIENT_CHANGE_MASK_PROPS)
+		changed++;
+
+	if (changed) {
+		o->changed += changed;
+		core_sync(o->data);
+	}
+}
+
+static const struct pw_client_events client_events = {
+	PW_VERSION_CLIENT_EVENTS,
+	.info = client_event_info,
+};
+
+static void client_destroy(struct object *o)
+{
+	if (o->info) {
+		pw_client_info_free(o->info);
+		o->info = NULL;
+	}
+}
+
+static const struct class client_class = {
+	.type = PW_TYPE_INTERFACE_Client,
+	.version = PW_VERSION_CLIENT,
+	.events = &client_events,
+	.destroy = client_destroy,
+	.dump = client_dump,
+	.name_key = PW_KEY_APP_NAME,
+};
+
+/* module */
+static void module_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "props", PW_MODULE_CHANGE_MASK_PROPS },
+		{ NULL, 0 },
+	};
+
+	struct data *d = o->data;
+	struct pw_module_info *i = o->info;
+
+	put_begin(d, "info", "{", 0);
+	put_value(d, "name", i->name);
+	put_value(d, "filename", i->filename);
+	put_value(d, "args", i->args);
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_dict(d, "props", i->props);
+	put_end(d, "}", 0);
+}
+
+static void module_event_info(void *data, const struct pw_module_info *info)
+{
+	struct object *o = data;
+	int changed = 0;
+
+	pw_log_debug("object %p: id:%d change-mask:%08"PRIx64, o, o->id, info->change_mask);
+
+	info = o->info = pw_module_info_update(o->info, info);
+	if (info == NULL)
+		return;
+
+	if (info->change_mask & PW_MODULE_CHANGE_MASK_PROPS)
+		changed++;
+
+	if (changed) {
+		o->changed += changed;
+		core_sync(o->data);
+	}
+}
+
+static const struct pw_module_events module_events = {
+	PW_VERSION_MODULE_EVENTS,
+	.info = module_event_info,
+};
+
+static void module_destroy(struct object *o)
+{
+	if (o->info) {
+		pw_module_info_free(o->info);
+		o->info = NULL;
+	}
+}
+
+static const struct class module_class = {
+	.type = PW_TYPE_INTERFACE_Module,
+	.version = PW_VERSION_MODULE,
+	.events = &module_events,
+	.destroy = module_destroy,
+	.dump = module_dump,
+	.name_key = PW_KEY_MODULE_NAME,
+};
+
+/* factory */
+static void factory_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "props", PW_FACTORY_CHANGE_MASK_PROPS },
+		{ NULL, 0 },
+	};
+
+	struct data *d = o->data;
+	struct pw_factory_info *i = o->info;
+
+	put_begin(d, "info", "{", 0);
+	put_value(d, "name", i->name);
+	put_value(d, "type", i->type);
+	put_int(d, "version", i->version);
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_dict(d, "props", i->props);
+	put_end(d, "}", 0);
+}
+
+static void factory_event_info(void *data, const struct pw_factory_info *info)
+{
+	struct object *o = data;
+	int changed = 0;
+
+	pw_log_debug("object %p: id:%d change-mask:%08"PRIx64, o, o->id, info->change_mask);
+
+	info = o->info = pw_factory_info_update(o->info, info);
+	if (info == NULL)
+		return;
+
+	if (info->change_mask & PW_FACTORY_CHANGE_MASK_PROPS)
+		changed++;
+
+	if (changed) {
+		o->changed += changed;
+		core_sync(o->data);
+	}
+}
+
+static const struct pw_factory_events factory_events = {
+	PW_VERSION_FACTORY_EVENTS,
+	.info = factory_event_info,
+};
+
+static void factory_destroy(struct object *o)
+{
+	if (o->info) {
+		pw_factory_info_free(o->info);
+		o->info = NULL;
+	}
+}
+
+static const struct class factory_class = {
+	.type = PW_TYPE_INTERFACE_Factory,
+	.version = PW_VERSION_FACTORY,
+	.events = &factory_events,
+	.destroy = factory_destroy,
+	.dump = factory_dump,
+	.name_key = PW_KEY_FACTORY_NAME,
+};
+
+/* device */
+static void device_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "props", PW_DEVICE_CHANGE_MASK_PROPS },
+		{ "params", PW_DEVICE_CHANGE_MASK_PARAMS },
+		{ NULL, 0 },
+	};
+
+	struct data *d = o->data;
+	struct pw_device_info *i = o->info;
+
+	put_begin(d, "info", "{", 0);
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_dict(d, "props", i->props);
+	put_params(d, "params", i->params, i->n_params, &o->param_list);
+	put_end(d, "}", 0);
+}
+
+static void device_event_info(void *data, const struct pw_device_info *info)
+{
+	struct object *o = data;
+	uint32_t i, changed = 0;
+	int res;
+
+	pw_log_debug("object %p: id:%d change-mask:%08"PRIx64, o, o->id, info->change_mask);
+
+	info = o->info = pw_device_info_update(o->info, info);
+	if (info == NULL)
+		return;
+
+	o->params = info->params;
+	o->n_params = info->n_params;
+
+	if (info->change_mask & PW_DEVICE_CHANGE_MASK_PROPS)
+		changed++;
+
+	if (info->change_mask & PW_DEVICE_CHANGE_MASK_PARAMS) {
+		for (i = 0; i < info->n_params; i++) {
+			uint32_t id = info->params[i].id;
+
+			if (info->params[i].user == 0)
+				continue;
+			info->params[i].user = 0;
+
+			changed++;
+			add_param(&o->pending_list, 0, id, NULL);
+			if (!(info->params[i].flags & SPA_PARAM_INFO_READ))
+				continue;
+
+			res = pw_device_enum_params((struct pw_device*)o->proxy,
+					++info->params[i].seq, id, 0, -1, NULL);
+			if (SPA_RESULT_IS_ASYNC(res))
+				info->params[i].seq = res;
+		}
+	}
+	if (changed) {
+		o->changed += changed;
+		core_sync(o->data);
+	}
+}
+
+static void device_event_param(void *data, int seq,
+		uint32_t id, uint32_t index, uint32_t next,
+		const struct spa_pod *param)
+{
+	struct object *o = data;
+	add_param(&o->pending_list, seq, id, param);
+}
+
+static const struct pw_device_events device_events = {
+	PW_VERSION_DEVICE_EVENTS,
+	.info = device_event_info,
+	.param = device_event_param,
+};
+
+static void device_destroy(struct object *o)
+{
+	if (o->info) {
+		pw_device_info_free(o->info);
+		o->info = NULL;
+	}
+}
+
+static const struct class device_class = {
+	.type = PW_TYPE_INTERFACE_Device,
+	.version = PW_VERSION_DEVICE,
+	.events = &device_events,
+	.destroy = device_destroy,
+	.dump = device_dump,
+	.name_key = PW_KEY_DEVICE_NAME,
+};
+
+/* node */
+static void node_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "input-ports", PW_NODE_CHANGE_MASK_INPUT_PORTS },
+		{ "output-ports", PW_NODE_CHANGE_MASK_OUTPUT_PORTS },
+		{ "state", PW_NODE_CHANGE_MASK_STATE },
+		{ "props", PW_NODE_CHANGE_MASK_PROPS },
+		{ "params", PW_NODE_CHANGE_MASK_PARAMS },
+		{ NULL, 0 },
+	};
+
+	struct data *d = o->data;
+	struct pw_node_info *i = o->info;
+
+	put_begin(d, "info", "{", 0);
+	put_int(d, "max-input-ports", i->max_input_ports);
+	put_int(d, "max-output-ports", i->max_output_ports);
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_int(d, "n-input-ports", i->n_input_ports);
+	put_int(d, "n-output-ports", i->n_output_ports);
+	put_value(d, "state", pw_node_state_as_string(i->state));
+	put_value(d, "error", i->error);
+	put_dict(d, "props", i->props);
+	put_params(d, "params", i->params, i->n_params, &o->param_list);
+	put_end(d, "}", 0);
+}
+
+static void node_event_info(void *data, const struct pw_node_info *info)
+{
+	struct object *o = data;
+	uint32_t i, changed = 0;
+	int res;
+
+	pw_log_debug("object %p: id:%d change-mask:%08"PRIx64, o, o->id, info->change_mask);
+
+	info = o->info = pw_node_info_update(o->info, info);
+	if (info == NULL)
+		return;
+
+	o->params = info->params;
+	o->n_params = info->n_params;
+
+	if (info->change_mask & PW_NODE_CHANGE_MASK_STATE)
+		changed++;
+
+	if (info->change_mask & PW_NODE_CHANGE_MASK_PROPS)
+		changed++;
+
+	if (info->change_mask & PW_NODE_CHANGE_MASK_PARAMS) {
+		for (i = 0; i < info->n_params; i++) {
+			uint32_t id = info->params[i].id;
+
+			if (info->params[i].user == 0)
+				continue;
+			info->params[i].user = 0;
+
+			changed++;
+			add_param(&o->pending_list, 0, id, NULL);
+			if (!(info->params[i].flags & SPA_PARAM_INFO_READ))
+				continue;
+
+			res = pw_node_enum_params((struct pw_node*)o->proxy,
+					++info->params[i].seq, id, 0, -1, NULL);
+			if (SPA_RESULT_IS_ASYNC(res))
+				info->params[i].seq = res;
+		}
+	}
+	if (changed) {
+		o->changed += changed;
+		core_sync(o->data);
+	}
+}
+
+static void node_event_param(void *data, int seq,
+		uint32_t id, uint32_t index, uint32_t next,
+		const struct spa_pod *param)
+{
+	struct object *o = data;
+	add_param(&o->pending_list, seq, id, param);
+}
+
+static const struct pw_node_events node_events = {
+	PW_VERSION_NODE_EVENTS,
+	.info = node_event_info,
+	.param = node_event_param,
+};
+
+static void node_destroy(struct object *o)
+{
+	if (o->info) {
+		pw_node_info_free(o->info);
+		o->info = NULL;
+	}
+}
+
+static const struct class node_class = {
+	.type = PW_TYPE_INTERFACE_Node,
+	.version = PW_VERSION_NODE,
+	.events = &node_events,
+	.destroy = node_destroy,
+	.dump = node_dump,
+	.name_key = PW_KEY_NODE_NAME,
+};
+
+/* port */
+static void port_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "props", PW_PORT_CHANGE_MASK_PROPS },
+		{ "params", PW_PORT_CHANGE_MASK_PARAMS },
+		{ NULL, },
+	};
+
+	struct data *d = o->data;
+	struct pw_port_info *i = o->info;
+
+	put_begin(d, "info", "{", 0);
+	put_value(d, "direction", pw_direction_as_string(i->direction));
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_dict(d, "props", i->props);
+	put_params(d, "params", i->params, i->n_params, &o->param_list);
+	put_end(d, "}", 0);
+}
+
+static void port_event_info(void *data, const struct pw_port_info *info)
+{
+	struct object *o = data;
+	uint32_t i, changed = 0;
+	int res;
+
+	pw_log_debug("object %p: id:%d change-mask:%08"PRIx64, o, o->id, info->change_mask);
+
+	info = o->info = pw_port_info_update(o->info, info);
+	if (info == NULL)
+		return;
+
+	o->params = info->params;
+	o->n_params = info->n_params;
+
+	if (info->change_mask & PW_PORT_CHANGE_MASK_PROPS)
+		changed++;
+
+	if (info->change_mask & PW_PORT_CHANGE_MASK_PARAMS) {
+		for (i = 0; i < info->n_params; i++) {
+			uint32_t id = info->params[i].id;
+
+			if (info->params[i].user == 0)
+				continue;
+			info->params[i].user = 0;
+
+			changed++;
+			add_param(&o->pending_list, 0, id, NULL);
+			if (!(info->params[i].flags & SPA_PARAM_INFO_READ))
+				continue;
+
+			res = pw_port_enum_params((struct pw_port*)o->proxy,
+					++info->params[i].seq, id, 0, -1, NULL);
+			if (SPA_RESULT_IS_ASYNC(res))
+				info->params[i].seq = res;
+		}
+	}
+	if (changed) {
+		o->changed += changed;
+		core_sync(o->data);
+	}
+}
+
+static void port_event_param(void *data, int seq,
+		uint32_t id, uint32_t index, uint32_t next,
+		const struct spa_pod *param)
+{
+	struct object *o = data;
+	add_param(&o->pending_list, seq, id, param);
+}
+
+static const struct pw_port_events port_events = {
+	PW_VERSION_PORT_EVENTS,
+	.info = port_event_info,
+	.param = port_event_param,
+};
+
+static void port_destroy(struct object *o)
+{
+	if (o->info) {
+		pw_port_info_free(o->info);
+		o->info = NULL;
+	}
+}
+
+static const struct class port_class = {
+	.type = PW_TYPE_INTERFACE_Port,
+	.version = PW_VERSION_PORT,
+	.events = &port_events,
+	.destroy = port_destroy,
+	.dump = port_dump,
+	.name_key = PW_KEY_PORT_NAME,
+};
+
+/* link */
+static void link_dump(struct object *o)
+{
+	static const struct flags_info fl[] = {
+		{ "state", PW_LINK_CHANGE_MASK_STATE },
+		{ "format", PW_LINK_CHANGE_MASK_FORMAT },
+		{ "props", PW_LINK_CHANGE_MASK_PROPS },
+		{ NULL, },
+	};
+
+	struct data *d = o->data;
+	struct pw_link_info *i = o->info;
+
+	put_begin(d, "info", "{", 0);
+	put_int(d, "output-node-id", i->output_node_id);
+	put_int(d, "output-port-id", i->output_port_id);
+	put_int(d, "input-node-id", i->input_node_id);
+	put_int(d, "input-port-id", i->input_port_id);
+	put_flags(d, "change-mask", i->change_mask, fl);
+	put_value(d, "state", pw_link_state_as_string(i->state));
+	put_value(d, "error", i->error);
+	put_pod(d, "format", i->format);
+	put_dict(d, "props", i->props);
+	put_end(d, "}", 0);
+}
+
+static void link_event_info(void *data, const struct pw_link_info *info)
+{
+	struct object *o = data;
+	uint32_t changed = 0;
+
+	pw_log_debug("object %p: id:%d change-mask:%08"PRIx64, o, o->id, info->change_mask);
+
+	info = o->info = pw_link_info_update(o->info, info);
+	if (info == NULL)
+		return;
+
+	if (info->change_mask & PW_LINK_CHANGE_MASK_STATE)
+		changed++;
+
+	if (info->change_mask & PW_LINK_CHANGE_MASK_FORMAT)
+		changed++;
+
+	if (info->change_mask & PW_LINK_CHANGE_MASK_PROPS)
+		changed++;
+
+	if (changed) {
+		o->changed += changed;
+		core_sync(o->data);
+	}
+}
+
+static const struct pw_link_events link_events = {
+	PW_VERSION_PORT_EVENTS,
+	.info = link_event_info,
+};
+
+static void link_destroy(struct object *o)
+{
+	if (o->info) {
+		pw_link_info_free(o->info);
+		o->info = NULL;
+	}
+}
+
+static const struct class link_class = {
+	.type = PW_TYPE_INTERFACE_Link,
+	.version = PW_VERSION_LINK,
+	.events = &link_events,
+	.destroy = link_destroy,
+	.dump = link_dump,
+};
+
+static void json_dump_val(struct data *d, const char *key, struct spa_json *it, const char *value, int len)
+{
+	struct spa_json sub;
+	if (spa_json_is_array(value, len)) {
+		put_begin(d, key, "[", STATE_SIMPLE);
+		spa_json_enter(it, &sub);
+		while ((len = spa_json_next(&sub, &value)) > 0) {
+			json_dump_val(d, NULL, &sub, value, len);
+		}
+		put_end(d, "]", STATE_SIMPLE);
+	} else if (spa_json_is_object(value, len)) {
+		char val[1024];
+		put_begin(d, key, "{", STATE_SIMPLE);
+		spa_json_enter(it, &sub);
+		while (spa_json_get_string(&sub, val, sizeof(val)) > 0) {
+			if ((len = spa_json_next(&sub, &value)) <= 0)
+				break;
+			json_dump_val(d, val, &sub, value, len);
+		}
+		put_end(d, "}", STATE_SIMPLE);
+	} else if (spa_json_is_string(value, len)) {
+		put_encoded_string(d, key, strndupa(value, len));
+	} else {
+		put_value(d, key, strndupa(value, len));
+	}
+}
+
+static void json_dump(struct data *d, const char *key, const char *value)
+{
+	struct spa_json it[1];
+	int len;
+	const char *val;
+	spa_json_init(&it[0], value, strlen(value));
+	if ((len = spa_json_next(&it[0], &val)) >= 0)
+		json_dump_val(d, key, &it[0], val, len);
+}
+
+/* metadata */
+
+struct metadata_entry {
+	struct spa_list link;
+	uint32_t changed;
+	uint32_t subject;
+	char *key;
+	char *value;
+	char *type;
+};
+
+static void metadata_dump(struct object *o)
+{
+	struct data *d = o->data;
+	struct metadata_entry *e;
+	put_dict(d, "props", &o->props->dict);
+	put_begin(d, "metadata", "[", 0);
+	spa_list_for_each(e, &o->data_list, link) {
+		if (e->changed == 0)
+			continue;
+		put_begin(d, NULL, "{", STATE_SIMPLE);
+		put_int(d, "subject", e->subject);
+		put_value(d, "key", e->key);
+		put_value(d, "type", e->type);
+		if (e->type != NULL && spa_streq(e->type, "Spa:String:JSON"))
+			json_dump(d, "value", e->value);
+		else
+			put_value(d, "value", e->value);
+		put_end(d, "}", STATE_SIMPLE);
+		e->changed = 0;
+	}
+	put_end(d, "]", 0);
+}
+
+static struct metadata_entry *metadata_find(struct object *o, uint32_t subject, const char *key)
+{
+	struct metadata_entry *e;
+	spa_list_for_each(e, &o->data_list, link) {
+		if ((e->subject == subject) &&
+		    (key == NULL || spa_streq(e->key, key)))
+			return e;
+	}
+	return NULL;
+}
+
+static int metadata_property(void *data,
+			uint32_t subject,
+			const char *key,
+			const char *type,
+			const char *value)
+{
+	struct object *o = data;
+	struct metadata_entry *e;
+
+	while ((e = metadata_find(o, subject, key)) != NULL) {
+		spa_list_remove(&e->link);
+		free(e);
+	}
+	if (key != NULL && value != NULL) {
+		size_t size = strlen(key) + 1;
+		size += strlen(value) + 1;
+		size += type ? strlen(type) + 1 : 0;
+
+		e = calloc(1, sizeof(*e) + size);
+		if (e == NULL)
+			return -errno;
+
+		e->subject = subject;
+		e->key = SPA_PTROFF(e, sizeof(*e), void);
+		strcpy(e->key, key);
+		e->value = SPA_PTROFF(e->key, strlen(e->key) + 1, void);
+		strcpy(e->value, value);
+		if (type) {
+			e->type = SPA_PTROFF(e->value, strlen(e->value) + 1, void);
+			strcpy(e->type, type);
+		} else {
+			e->type = NULL;
+		}
+		spa_list_append(&o->data_list, &e->link);
+		e->changed++;
+	}
+	o->changed++;
+	return 0;
+}
+
+static const struct pw_metadata_events metadata_events = {
+	PW_VERSION_METADATA_EVENTS,
+	.property = metadata_property,
+};
+
+static void metadata_destroy(struct object *o)
+{
+	struct metadata_entry *e;
+	spa_list_consume(e, &o->data_list, link) {
+		spa_list_remove(&e->link);
+		free(e);
+	}
+}
+
+static const struct class metadata_class = {
+	.type = PW_TYPE_INTERFACE_Metadata,
+	.version = PW_VERSION_METADATA,
+	.events = &metadata_events,
+	.destroy = metadata_destroy,
+	.dump = metadata_dump,
+	.name_key = PW_KEY_METADATA_NAME,
+};
+
+static const struct class *classes[] =
+{
+	&core_class,
+	&module_class,
+	&factory_class,
+	&client_class,
+	&device_class,
+	&node_class,
+	&port_class,
+	&link_class,
+	&metadata_class,
+};
+
+static const struct class *find_class(const char *type, uint32_t version)
+{
+	SPA_FOR_EACH_ELEMENT_VAR(classes, c) {
+		if (spa_streq((*c)->type, type) &&
+		    (*c)->version <= version)
+			return *c;
+	}
+	return NULL;
+}
+
+static void
+destroy_removed(void *data)
+{
+	struct object *o = data;
+	pw_proxy_destroy(o->proxy);
+}
+
+static void
+destroy_proxy(void *data)
+{
+	struct object *o = data;
+
+	spa_hook_remove(&o->proxy_listener);
+	if (o->class != NULL) {
+		if (o->class->events)
+			spa_hook_remove(&o->object_listener);
+		if (o->class->destroy)
+	                o->class->destroy(o);
+	}
+        o->proxy = NULL;
+}
+
+static const struct pw_proxy_events proxy_events = {
+        PW_VERSION_PROXY_EVENTS,
+        .removed = destroy_removed,
+        .destroy = destroy_proxy,
+};
+
+static void registry_event_global(void *data, uint32_t id,
+			uint32_t permissions, const char *type, uint32_t version,
+			const struct spa_dict *props)
+{
+	struct data *d = data;
+	struct object *o;
+
+	o = calloc(1, sizeof(*o));
+	if (o == NULL) {
+		pw_log_error("can't alloc object for %u %s/%d: %m", id, type, version);
+		return;
+	}
+	o->data = d;
+	o->id = id;
+	o->permissions = permissions;
+	o->type = strdup(type);
+	o->version = version;
+	o->props = props ? pw_properties_new_dict(props) : NULL;
+	spa_list_init(&o->param_list);
+	spa_list_init(&o->pending_list);
+	spa_list_init(&o->data_list);
+
+	o->class = find_class(type, version);
+	if (o->class != NULL) {
+		o->proxy = pw_registry_bind(d->registry,
+				id, type, o->class->version, 0);
+		if (o->proxy == NULL)
+			goto bind_failed;
+
+		pw_proxy_add_listener(o->proxy,
+				&o->proxy_listener,
+				&proxy_events, o);
+
+		if (o->class->events)
+			pw_proxy_add_object_listener(o->proxy,
+					&o->object_listener,
+					o->class->events, o);
+		else
+			o->changed++;
+	} else {
+		o->changed++;
+	}
+	spa_list_append(&d->object_list, &o->link);
+
+	core_sync(d);
+	return;
+
+bind_failed:
+	pw_log_error("can't bind object for %u %s/%d: %m", id, type, version);
+	pw_properties_free(o->props);
+	free(o);
+	return;
+}
+
+static bool object_matches(struct object *o, const char *pattern)
+{
+	uint32_t id;
+	const char *str;
+
+	if (spa_atou32(pattern, &id, 0) && o->id == id)
+		return true;
+
+	if (o->props == NULL)
+		return false;
+
+	if (strstr(o->type, pattern) != NULL)
+		return true;
+	if ((str = pw_properties_get(o->props, PW_KEY_OBJECT_PATH)) != NULL &&
+	    fnmatch(pattern, str, FNM_EXTMATCH) == 0)
+		return true;
+	if ((str = pw_properties_get(o->props, PW_KEY_OBJECT_SERIAL)) != NULL &&
+	    spa_streq(pattern, str))
+		return true;
+	if (o->class != NULL && o->class->name_key != NULL &&
+	    (str = pw_properties_get(o->props, o->class->name_key)) != NULL &&
+	    fnmatch(pattern, str, FNM_EXTMATCH) == 0)
+		return true;
+	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[] = {
+		{ "r", PW_PERM_R },
+		{ "w", PW_PERM_W },
+		{ "x", PW_PERM_X },
+		{ "m", PW_PERM_M },
+		{ NULL, },
+	};
+
+	struct object *o;
+
+	d->state = STATE_FIRST;
+	spa_list_for_each(o, &d->object_list, link) {
+		if (d->pattern != NULL && !object_matches(o, d->pattern))
+			continue;
+		if (o->changed == 0)
+			continue;
+		if (d->state == STATE_FIRST)
+			put_begin(d, NULL, "[", 0);
+		put_begin(d, NULL, "{", 0);
+		put_int(d, "id", o->id);
+		put_value(d, "type", o->type);
+		put_int(d, "version", o->version);
+		put_flags(d, "permissions", o->permissions, fl);
+		if (o->class && o->class->dump)
+			o->class->dump(o);
+		else if (o->props)
+			put_dict(d, "props", &o->props->dict);
+		put_end(d, "}", 0);
+		o->changed = 0;
+	}
+	if (d->state != STATE_FIRST)
+		put_end(d, "]\n", 0);
+}
+
+static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
+{
+	struct 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)
+		pw_main_loop_quit(d->loop);
+}
+
+static void on_core_info(void *data, const struct pw_core_info *info)
+{
+	struct data *d = data;
+	d->info = pw_core_info_update(d->info, info);
+}
+
+static void on_core_done(void *data, uint32_t id, int seq)
+{
+	struct data *d = data;
+	struct object *o;
+
+	if (id == PW_ID_CORE) {
+		if (d->sync_seq != seq)
+			return;
+
+		pw_log_debug("sync end %u/%u", d->sync_seq, seq);
+
+		spa_list_for_each(o, &d->object_list, link)
+			object_update_params(&o->param_list, &o->pending_list,
+					o->n_params, o->params);
+
+		dump_objects(d);
+		if (!d->monitor)
+			pw_main_loop_quit(d->loop);
+	}
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.done = on_core_done,
+	.info = on_core_info,
+	.error = on_core_error,
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static void show_help(struct data *data, const char *name, bool error)
+{
+	fprintf(error ? stderr : stdout, "%s [options] [<id>]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote                          Remote daemon name\n"
+		"  -m, --monitor                         monitor changes\n"
+		"  -N, --no-colors                       disable color output\n"
+		"  -C, --color[=WHEN]                    whether to enable color support. WHEN is `never`, `always`, or `auto`\n",
+		name);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct object *o;
+	struct pw_loop *l;
+	const char *opt_remote = NULL;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ "monitor",	no_argument,		NULL, 'm' },
+		{ "no-colors",	no_argument,		NULL, 'N' },
+		{ "color",	optional_argument,	NULL, 'C' },
+		{ NULL, 0, NULL, 0}
+	};
+	int c;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	data.out = stdout;
+	if (isatty(fileno(data.out)) && getenv("NO_COLOR") == NULL)
+		colors = true;
+	setlinebuf(data.out);
+
+	while ((c = getopt_long(argc, argv, "hVr:mNC", 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 'm' :
+			data.monitor = true;
+			break;
+		case 'N' :
+			colors = false;
+			break;
+		case 'C' :
+			if (optarg == NULL || !strcmp(optarg, "auto"))
+				break; /* nothing to do, tty detection was done
+					  before parsing options */
+			else if (!strcmp(optarg, "never"))
+				colors = false;
+			else if (!strcmp(optarg, "always"))
+				colors = true;
+			else {
+				fprintf(stderr, "Unknown color: %s\n", optarg);
+				show_help(&data, argv[0], true);
+				return -1;
+			}
+			break;
+		default:
+			show_help(&data, argv[0], true);
+			return -1;
+		}
+	}
+
+	if (optind < argc)
+		data.pattern = argv[optind++];
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "can't create main loop: %m\n");
+		return -1;
+	}
+
+	l = pw_main_loop_get_loop(data.loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data.context = pw_context_new(l, NULL, 0);
+	if (data.context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		return -1;
+	}
+
+	data.core = pw_context_connect(data.context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, opt_remote,
+				NULL),
+			0);
+	if (data.core == NULL) {
+		fprintf(stderr, "can't connect: %m\n");
+		return -1;
+	}
+
+	spa_list_init(&data.object_list);
+
+	pw_core_add_listener(data.core,
+			&data.core_listener,
+			&core_events, &data);
+	data.registry = pw_core_get_registry(data.core,
+			PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data.registry,
+			&data.registry_listener,
+			&registry_events, &data);
+
+	pw_main_loop_run(data.loop);
+
+	spa_list_consume(o, &data.object_list, link)
+		object_destroy(o);
+	if (data.info)
+		pw_core_info_free(data.info);
+
+	spa_hook_remove(&data.registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data.registry);
+	spa_hook_remove(&data.core_listener);
+	pw_context_destroy(data.context);
+	pw_main_loop_destroy(data.loop);
+	pw_deinit();
+
+	return 0;
+}
diff --git a/src/tools/pw-link.c b/src/tools/pw-link.c
new file mode 100644
index 0000000..8696eb2
--- /dev/null
+++ b/src/tools/pw-link.c
@@ -0,0 +1,912 @@
+/* PipeWire
+ *
+ * Copyright © 2021 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 <stdio.h>
+#include <signal.h>
+#include <math.h>
+#include <getopt.h>
+#include <regex.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/utils/defs.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/filter.h>
+
+struct object {
+	struct spa_list link;
+
+	uint32_t id;
+#define OBJECT_ANY	0
+#define OBJECT_NODE	1
+#define OBJECT_PORT	2
+#define OBJECT_LINK	3
+	uint32_t type;
+	struct pw_properties *props;
+	uint32_t extra[2];
+};
+
+struct data {
+	struct pw_main_loop *loop;
+
+	const char *opt_remote;
+#define MODE_LIST_OUTPUT	(1<<0)
+#define MODE_LIST_INPUT		(1<<1)
+#define MODE_LIST_PORTS		(MODE_LIST_OUTPUT|MODE_LIST_INPUT)
+#define MODE_LIST_LINKS		(1<<2)
+#define MODE_LIST		(MODE_LIST_PORTS|MODE_LIST_LINKS)
+#define MODE_MONITOR		(1<<3)
+#define MODE_DISCONNECT		(1<<4)
+	uint32_t opt_mode;
+	bool opt_id;
+	bool opt_verbose;
+	const char *opt_output;
+	const char *opt_input;
+	struct pw_properties *props;
+
+	struct pw_context *context;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct spa_list objects;
+
+	int sync;
+	int link_res;
+	bool monitoring;
+	bool list_inputs;
+	bool list_outputs;
+	const char *prefix;
+
+	regex_t out_port_regex, *out_regex;
+	regex_t in_port_regex, *in_regex;
+};
+
+static void link_proxy_error(void *data, int seq, int res, const char *message)
+{
+	struct data *d = data;
+	d->link_res = res;
+}
+
+static const struct pw_proxy_events link_proxy_events = {
+	PW_VERSION_PROXY_EVENTS,
+	.error = link_proxy_error,
+};
+
+static void core_sync(struct data *data)
+{
+	data->sync = pw_core_sync(data->core, PW_ID_CORE, data->sync);
+}
+
+static int create_link(struct data *data)
+{
+	struct pw_proxy *proxy;
+	struct spa_hook listener;
+
+	data->link_res = 0;
+
+	proxy = pw_core_create_object(data->core,
+			"link-factory",
+			PW_TYPE_INTERFACE_Link,
+			PW_VERSION_LINK,
+			&data->props->dict, 0);
+	if (proxy == NULL)
+		return -errno;
+
+	spa_zero(listener);
+	pw_proxy_add_listener(proxy, &listener, &link_proxy_events, data);
+
+	core_sync(data);
+	pw_main_loop_run(data->loop);
+
+        spa_hook_remove(&listener);
+
+        pw_proxy_destroy(proxy);
+
+	return data->link_res;
+}
+
+static struct object *find_object(struct data *data, uint32_t type, uint32_t id)
+{
+	struct object *o;
+	spa_list_for_each(o, &data->objects, link)
+		if ((type == OBJECT_ANY || o->type == type) && o->id == id)
+			return o;
+	return NULL;
+}
+
+static struct object *find_node_port(struct data *data, struct object *node, enum pw_direction direction, const char *port_id)
+{
+	struct object *o;
+
+	spa_list_for_each(o, &data->objects, link) {
+		const char *o_port_id;
+		if (o->type != OBJECT_PORT)
+			continue;
+		if (o->extra[1] != node->id)
+			continue;
+		if (o->extra[0] != direction)
+			continue;
+		if ((o_port_id = pw_properties_get(o->props, PW_KEY_PORT_ID)) == NULL)
+			continue;
+		if (spa_streq(o_port_id, port_id))
+			return o;
+	}
+
+	return NULL;
+}
+
+static char *node_name(char *buffer, int size, struct object *n)
+{
+	const char *name;
+	buffer[0] = '\0';
+	if ((name = pw_properties_get(n->props, PW_KEY_NODE_NAME)) == NULL)
+		return buffer;
+	snprintf(buffer, size, "%s", name);
+	return buffer;
+}
+
+static char *node_path(char *buffer, int size, struct object *n)
+{
+	const char *name;
+	buffer[0] = '\0';
+	if ((name = pw_properties_get(n->props, PW_KEY_OBJECT_PATH)) == NULL)
+		return buffer;
+	snprintf(buffer, size, "%s", name);
+	return buffer;
+}
+
+static char *port_name(char *buffer, int size, struct object *n, struct object *p)
+{
+	const char *name1, *name2;
+	buffer[0] = '\0';
+	if ((name1 = pw_properties_get(n->props, PW_KEY_NODE_NAME)) == NULL)
+		return buffer;
+	if ((name2 = pw_properties_get(p->props, PW_KEY_PORT_NAME)) == NULL)
+		return buffer;
+	snprintf(buffer, size, "%s:%s", name1, name2);
+	return buffer;
+}
+
+static char *port_path(char *buffer, int size, struct object *n, struct object *p)
+{
+	const char *name;
+	buffer[0] = '\0';
+	if ((name = pw_properties_get(p->props, PW_KEY_OBJECT_PATH)) == NULL)
+		return buffer;
+	snprintf(buffer, size, "%s", name);
+	return buffer;
+}
+
+static char *port_alias(char *buffer, int size, struct object *n, struct object *p)
+{
+	const char *name;
+	buffer[0] = '\0';
+	if ((name = pw_properties_get(p->props, PW_KEY_PORT_ALIAS)) == NULL)
+		return buffer;
+	snprintf(buffer, size, "%s", name);
+	return buffer;
+}
+
+static void print_port(struct data *data, const char *prefix, struct object *n,
+		struct object *p, bool verbose)
+{
+	char buffer[1024], id[64] = "", *prefix2 = "";
+	if (data->opt_id) {
+		snprintf(id, sizeof(id), "%4d ", p->id);
+		prefix2 = "     ";
+	}
+
+	printf("%s%s%s%s\n", data->prefix, prefix,
+			id, port_name(buffer, sizeof(buffer), n, p));
+	if (verbose) {
+		port_path(buffer, sizeof(buffer), n, p);
+		if (buffer[0] != '\0')
+			printf("%s  %s%s%s\n", data->prefix, prefix2, prefix, buffer);
+		port_alias(buffer, sizeof(buffer), n, p);
+		if (buffer[0] != '\0')
+			printf("%s  %s%s%s\n", data->prefix, prefix2, prefix, buffer);
+	}
+}
+
+static void print_port_id(struct data *data, const char *prefix, uint32_t peer)
+{
+	struct object *n, *p;
+	if ((p = find_object(data, OBJECT_PORT, peer)) == NULL)
+		return;
+	if ((n = find_object(data, OBJECT_NODE, p->extra[1])) == NULL)
+		return;
+	print_port(data, prefix, n, p, false);
+}
+
+static void do_list_port_links(struct data *data, struct object *node, struct object *port)
+{
+	struct object *o;
+	bool first = false;
+
+	if ((data->opt_mode & MODE_LIST_PORTS) == 0)
+		first = true;
+
+	spa_list_for_each(o, &data->objects, link) {
+		uint32_t peer;
+		char prefix[64], id[16] = "";
+
+		if (data->opt_id)
+			snprintf(id, sizeof(id), "%4d ", o->id);
+
+		if (o->type != OBJECT_LINK)
+			continue;
+
+		if (port->extra[0] == PW_DIRECTION_OUTPUT &&
+		    o->extra[0] == port->id) {
+			peer = o->extra[1];
+			snprintf(prefix, sizeof(prefix), "%s  |-> ", id);
+		}
+		else if (port->extra[0] == PW_DIRECTION_INPUT &&
+		    o->extra[1] == port->id) {
+			peer = o->extra[0];
+			snprintf(prefix, sizeof(prefix), "%s  |<- ", id);
+		}
+		else
+			continue;
+
+		if (first) {
+			print_port(data, "", node, port, data->opt_verbose);
+			first = false;
+		}
+		print_port_id(data, prefix, peer);
+	}
+}
+
+static int node_matches(struct data *data, struct object *n, const char *name)
+{
+	char buffer[1024];
+	uint32_t id = atoi(name);
+	if (n->id == id)
+		return 1;
+	if (spa_streq(node_name(buffer, sizeof(buffer), n), name))
+		return 1;
+	if (spa_streq(node_path(buffer, sizeof(buffer), n), name))
+		return 1;
+	return 0;
+}
+
+static int port_matches(struct data *data, struct object *n, struct object *p, const char *name)
+{
+	char buffer[1024];
+	uint32_t id = atoi(name);
+	if (p->id == id)
+		return 1;
+	if (spa_streq(port_name(buffer, sizeof(buffer), n, p), name))
+		return 1;
+	if (spa_streq(port_path(buffer, sizeof(buffer), n, p), name))
+		return 1;
+	if (spa_streq(port_alias(buffer, sizeof(buffer), n, p), name))
+		return 1;
+	return 0;
+}
+
+static int port_regex(struct data *data, struct object *n, struct object *p, regex_t *regex)
+{
+	char buffer[1024];
+	if (regexec(regex, port_name(buffer, sizeof(buffer), n, p), 0, NULL, 0) == 0)
+		return 1;
+	return 0;
+}
+
+static void do_list_ports(struct data *data, struct object *node,
+		enum pw_direction direction, regex_t *regex)
+{
+	struct object *o;
+	spa_list_for_each(o, &data->objects, link) {
+		if (o->type != OBJECT_PORT)
+			continue;
+		if (o->extra[1] != node->id)
+			continue;
+		if (o->extra[0] != direction)
+			continue;
+
+		if (regex && !port_regex(data, node, o, regex))
+			continue;
+
+		if (data->opt_mode & MODE_LIST_PORTS)
+			print_port(data, "", node, o, data->opt_verbose);
+		if (data->opt_mode & MODE_LIST_LINKS)
+			do_list_port_links(data, node, o);
+	}
+}
+
+static void do_list(struct data *data)
+{
+	struct object *n;
+
+	spa_list_for_each(n, &data->objects, link) {
+		if (n->type != OBJECT_NODE)
+			continue;
+		if (data->list_outputs)
+			do_list_ports(data, n, PW_DIRECTION_OUTPUT, data->out_regex);
+		if (data->list_inputs)
+			do_list_ports(data, n, PW_DIRECTION_INPUT, data->in_regex);
+	}
+}
+
+static int do_link_ports(struct data *data)
+{
+	uint32_t in_port = 0, out_port = 0;
+	struct object *n, *p;
+	struct object *in_node = NULL, *out_node = NULL;
+
+	spa_list_for_each(n, &data->objects, link) {
+		if (n->type != OBJECT_NODE)
+			continue;
+
+		if (out_node == NULL && node_matches(data, n, data->opt_output)) {
+			out_node = n;
+			continue;
+		} else if (in_node == NULL && node_matches(data, n, data->opt_input)) {
+			in_node = n;
+			continue;
+		}
+
+		spa_list_for_each(p, &data->objects, link) {
+			if (p->type != OBJECT_PORT)
+				continue;
+			if (p->extra[1] != n->id)
+				continue;
+
+			if (out_port == 0 && p->extra[0] == PW_DIRECTION_OUTPUT &&
+			    port_matches(data, n, p, data->opt_output))
+				out_port = p->id;
+			else if (in_port == 0 && p->extra[0] == PW_DIRECTION_INPUT &&
+			    port_matches(data, n, p, data->opt_input))
+				in_port = p->id;
+		}
+	}
+
+	if (in_node && out_node) {
+		int i, ret;
+		char port_id[32];
+		bool all_links_exist = true;
+
+		for (i=0;; i++) {
+			snprintf(port_id, sizeof(port_id), "%d", i);
+
+			struct object *port_out = find_node_port(data, out_node, PW_DIRECTION_OUTPUT, port_id);
+			struct object *port_in = find_node_port(data, in_node, PW_DIRECTION_INPUT, port_id);
+
+			if (!port_out && !port_in) {
+				fprintf(stderr, "Input & output port do not exist\n");
+				goto no_port;
+			} else if (!port_in) {
+				fprintf(stderr, "Input port does not exist\n");
+				goto no_port;
+			} else if (!port_out) {
+				fprintf(stderr, "Output port does not exist\n");
+				goto no_port;
+			}
+
+			pw_properties_setf(data->props, PW_KEY_LINK_OUTPUT_PORT, "%u", port_out->id);
+			pw_properties_setf(data->props, PW_KEY_LINK_INPUT_PORT, "%u", port_in->id);
+
+			if ((ret = create_link(data)) < 0 && ret != -EEXIST)
+				return ret;
+
+			if (ret >= 0)
+				all_links_exist = false;
+		}
+		return (all_links_exist ? -EEXIST : 0);
+	}
+
+	if (in_port == 0 || out_port == 0)
+		return -ENOENT;
+
+	pw_properties_setf(data->props, PW_KEY_LINK_OUTPUT_PORT, "%u", out_port);
+	pw_properties_setf(data->props, PW_KEY_LINK_INPUT_PORT, "%u", in_port);
+
+	return create_link(data);
+
+no_port:
+	return -ENOENT;
+}
+
+static int do_unlink_ports(struct data *data)
+{
+	struct object *l, *n, *p;
+	bool found_any = false;
+	struct object *in_node = NULL, *out_node = NULL;
+
+	if (data->opt_input != NULL) {
+		/* 2 args, check if they are node names */
+		spa_list_for_each(n, &data->objects, link) {
+			if (n->type != OBJECT_NODE)
+				continue;
+
+			if (out_node == NULL && node_matches(data, n, data->opt_output)) {
+				out_node = n;
+				continue;
+			} else if (in_node == NULL && node_matches(data, n, data->opt_input)) {
+				in_node = n;
+				continue;
+			}
+		}
+	}
+
+	spa_list_for_each(l, &data->objects, link) {
+		if (l->type != OBJECT_LINK)
+			continue;
+
+		if (data->opt_input == NULL) {
+			/* 1 arg, check link id */
+			if (l->id != (uint32_t)atoi(data->opt_output))
+				continue;
+		} else if (out_node && in_node) {
+			/* 2 args, check nodes */
+			if ((p = find_object(data, OBJECT_PORT, l->extra[0])) == NULL)
+				continue;
+			if ((n = find_object(data, OBJECT_NODE, p->extra[1])) == NULL)
+				continue;
+			if (n->id != out_node->id)
+				continue;
+
+			if ((p = find_object(data, OBJECT_PORT, l->extra[1])) == NULL)
+				continue;
+			if ((n = find_object(data, OBJECT_NODE, p->extra[1])) == NULL)
+				continue;
+			if (n->id != in_node->id)
+				continue;
+		} else {
+			/* 2 args, check port names */
+			if ((p = find_object(data, OBJECT_PORT, l->extra[0])) == NULL)
+				continue;
+			if ((n = find_object(data, OBJECT_NODE, p->extra[1])) == NULL)
+				continue;
+			if (!port_matches(data, n, p, data->opt_output))
+				continue;
+
+			if ((p = find_object(data, OBJECT_PORT, l->extra[1])) == NULL)
+				continue;
+			if ((n = find_object(data, OBJECT_NODE, p->extra[1])) == NULL)
+				continue;
+			if (!port_matches(data, n, p, data->opt_input))
+				continue;
+		}
+		pw_registry_destroy(data->registry, l->id);
+		found_any = true;
+	}
+	if (!found_any)
+		return -ENOENT;
+
+	core_sync(data);
+	pw_main_loop_run(data->loop);
+
+	return 0;
+}
+
+static int do_monitor_port(struct data *data, struct object *port)
+{
+	regex_t *regex = NULL;
+	bool do_print = false;
+	struct object *node;
+
+	if (port->extra[0] == PW_DIRECTION_OUTPUT && data->list_outputs) {
+		regex = data->out_regex;
+		do_print = true;
+	}
+	if (port->extra[0] == PW_DIRECTION_INPUT && data->list_inputs) {
+		regex = data->in_regex;
+		do_print = true;
+	}
+	if (!do_print)
+		return 0;
+
+	if ((node = find_object(data, OBJECT_NODE, port->extra[1])) == NULL)
+		return -ENOENT;
+
+	if (regex && !port_regex(data, node, port, regex))
+		return 0;
+
+	print_port(data, "", node, port, data->opt_verbose);
+	return 0;
+}
+
+static int do_monitor_link(struct data *data, struct object *link)
+{
+	char buffer1[1024], buffer2[1024], id[64] = "";
+	struct object *n1, *n2, *p1, *p2;
+
+	if (!(data->opt_mode & MODE_LIST_LINKS))
+		return 0;
+
+	if ((p1 = find_object(data, OBJECT_PORT, link->extra[0])) == NULL)
+		return -ENOENT;
+	if ((n1 = find_object(data, OBJECT_NODE, p1->extra[1])) == NULL)
+		return -ENOENT;
+	if (data->out_regex && !port_regex(data, n1, p1, data->out_regex))
+		return 0;
+
+	if ((p2 = find_object(data, OBJECT_PORT, link->extra[1])) == NULL)
+		return -ENOENT;
+	if ((n2 = find_object(data, OBJECT_NODE, p2->extra[1])) == NULL)
+		return -ENOENT;
+	if (data->in_regex && !port_regex(data, n2, p2, data->in_regex))
+		return 0;
+
+	if (data->opt_id)
+		snprintf(id, sizeof(id), "%4d ", link->id);
+
+	printf("%s%s%s -> %s\n", data->prefix, id,
+			port_name(buffer1, sizeof(buffer1), n1, p1),
+			port_name(buffer2, sizeof(buffer2), n2, p2));
+	return 0;
+}
+
+static void registry_event_global(void *data, uint32_t id, uint32_t permissions,
+				  const char *type, uint32_t version,
+				  const struct spa_dict *props)
+{
+	struct data *d = data;
+	uint32_t t, extra[2];
+	struct object *obj;
+	const char *str;
+
+	if (props == NULL)
+		return;
+
+	spa_zero(extra);
+	if (spa_streq(type, PW_TYPE_INTERFACE_Node)) {
+		t = OBJECT_NODE;
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Port)) {
+		t = OBJECT_PORT;
+		if ((str = spa_dict_lookup(props, PW_KEY_PORT_DIRECTION)) == NULL)
+			return;
+		if (spa_streq(str, "in"))
+			extra[0] = PW_DIRECTION_INPUT;
+		else if (spa_streq(str, "out"))
+			extra[0] = PW_DIRECTION_OUTPUT;
+		else
+			return;
+		if ((str = spa_dict_lookup(props, PW_KEY_NODE_ID)) == NULL)
+			return;
+		extra[1] = atoi(str);
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Link)) {
+		t = OBJECT_LINK;
+		if ((str = spa_dict_lookup(props, PW_KEY_LINK_OUTPUT_PORT)) == NULL)
+			return;
+		extra[0] = atoi(str);
+		if ((str = spa_dict_lookup(props, PW_KEY_LINK_INPUT_PORT)) == NULL)
+			return;
+		extra[1] = atoi(str);
+	} else
+		return;
+
+	obj = calloc(1, sizeof(*obj));
+	obj->type = t;
+	obj->id = id;
+	obj->props = pw_properties_new_dict(props);
+	memcpy(obj->extra, extra, sizeof(extra));
+	spa_list_append(&d->objects, &obj->link);
+
+	if (d->monitoring) {
+		d->prefix = "+ ";
+		switch (obj->type) {
+		case OBJECT_PORT:
+			do_monitor_port(d, obj);
+			break;
+		case OBJECT_LINK:
+			do_monitor_link(d, obj);
+			break;
+		}
+	}
+}
+
+static void registry_event_global_remove(void *data, uint32_t id)
+{
+	struct data *d = data;
+	struct object *obj;
+
+	if ((obj = find_object(d, OBJECT_ANY, id)) == NULL)
+		return;
+
+	if (d->monitoring) {
+		d->prefix = "- ";
+		switch (obj->type) {
+		case OBJECT_PORT:
+			do_monitor_port(d, obj);
+			break;
+		case OBJECT_LINK:
+			do_monitor_link(d, obj);
+			break;
+		}
+	}
+
+	spa_list_remove(&obj->link);
+	pw_properties_free(obj->props);
+	free(obj);
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+	.global_remove = registry_event_global_remove,
+};
+
+static void on_core_done(void *data, uint32_t id, int seq)
+{
+	struct data *d = data;
+	if (d->sync == seq)
+		pw_main_loop_quit(d->loop);
+}
+
+static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
+{
+	struct 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)
+		pw_main_loop_quit(d->loop);
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.done = on_core_done,
+	.error = on_core_error,
+};
+
+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 error)
+{
+        fprintf(error ? stderr : stdout, "%1$s : PipeWire port and link manager.\n"
+		"Generic: %1$s [options]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote=NAME                     Remote daemon name\n"
+		"List: %1$s [options] [out-pattern] [in-pattern]\n"
+		"  -o, --output                          List output ports\n"
+		"  -i, --input                           List input ports\n"
+		"  -l, --links                           List links\n"
+		"  -m, --monitor                         Monitor links and ports\n"
+		"  -I, --id                              List IDs\n"
+		"  -v, --verbose                         Verbose port properties\n"
+		"Connect: %1$s [options] output input\n"
+		"  -L, --linger                          Linger (default, unless -m is used)\n"
+		"  -P, --passive                         Passive link\n"
+		"  -p, --props=PROPS                     Properties as JSON object\n"
+		"Disconnect: %1$s -d [options] output input\n"
+		"            %1$s -d [options] link-id\n"
+		"  -d, --disconnect                      Disconnect ports\n",
+		name);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0, };
+	int res = 0, c;
+	regex_t out_port_regex;
+	regex_t in_port_regex;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ "output",	no_argument,		NULL, 'o' },
+		{ "input",	no_argument,		NULL, 'i' },
+		{ "links",	no_argument,		NULL, 'l' },
+		{ "monitor",	no_argument,		NULL, 'm' },
+		{ "id",		no_argument,		NULL, 'I' },
+		{ "verbose",	no_argument,		NULL, 'v' },
+		{ "linger",	no_argument,		NULL, 'L' },
+		{ "passive",	no_argument,		NULL, 'P' },
+		{ "props",	required_argument,	NULL, 'p' },
+		{ "disconnect",	no_argument,		NULL, 'd' },
+		{ NULL,	0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+	spa_list_init(&data.objects);
+
+	setlinebuf(stdout);
+
+	data.props = pw_properties_new(NULL, NULL);
+	if (data.props == NULL) {
+		fprintf(stderr, "can't create properties: %m\n");
+		return -1;
+	}
+
+	while ((c = getopt_long(argc, argv, "hVr:oilmIvLPp:d", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h':
+			show_help(&data, argv[0], NULL);
+			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':
+			data.opt_remote = optarg;
+			break;
+		case 'o':
+			data.opt_mode |= MODE_LIST_OUTPUT;
+			break;
+		case 'i':
+			data.opt_mode |= MODE_LIST_INPUT;
+			break;
+		case 'l':
+			data.opt_mode |= MODE_LIST_LINKS;
+			break;
+		case 'm':
+			data.opt_mode |= MODE_MONITOR;
+			break;
+		case 'I':
+			data.opt_id = true;
+			break;
+		case 'v':
+			data.opt_verbose = true;
+			break;
+		case 'L':
+			pw_properties_set(data.props, PW_KEY_OBJECT_LINGER, "true");
+			break;
+		case 'P':
+			pw_properties_set(data.props, PW_KEY_LINK_PASSIVE, "true");
+			break;
+		case 'p':
+			pw_properties_update_string(data.props, optarg, strlen(optarg));
+			break;
+		case 'd':
+			data.opt_mode |= MODE_DISCONNECT;
+			break;
+		default:
+			show_help(&data, argv[0], true);
+			return -1;
+		}
+	}
+	if (argc == 1)
+		show_help(&data, argv[0], true);
+
+	if (data.opt_id && (data.opt_mode & MODE_LIST) == 0) {
+		fprintf(stderr, "-I option needs one or more of -l, -i or -o\n");
+		return -1;
+	}
+
+	if ((data.opt_mode & MODE_MONITOR) == 0)
+		pw_properties_set(data.props, PW_KEY_OBJECT_LINGER, "true");
+
+	if (optind < argc)
+		data.opt_output = argv[optind++];
+	if (optind < argc)
+		data.opt_input = argv[optind++];
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "can't create mainloop: %m\n");
+		return -1;
+	}
+	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);
+
+	data.context = pw_context_new(pw_main_loop_get_loop(data.loop), NULL, 0);
+	if (data.context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		return -1;
+	}
+
+	data.core = pw_context_connect(data.context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, data.opt_remote,
+				NULL),
+			0);
+	if (data.core == NULL) {
+		fprintf(stderr, "can't connect: %m\n");
+		return -1;
+	}
+
+	pw_core_add_listener(data.core,
+			&data.core_listener,
+			&core_events, &data);
+
+	data.registry = pw_core_get_registry(data.core,
+			PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data.registry,
+			&data.registry_listener,
+			&registry_events, &data);
+
+	data.prefix = (data.opt_mode & MODE_MONITOR) ? "= " : "";
+
+	core_sync(&data);
+	pw_main_loop_run(data.loop);
+
+	if ((data.opt_mode & (MODE_LIST_PORTS|MODE_LIST_LINKS)) == MODE_LIST_LINKS)
+		data.list_inputs = data.list_outputs = true;
+	if ((data.opt_mode & MODE_LIST_INPUT) == MODE_LIST_INPUT)
+		data.list_inputs = true;
+	if ((data.opt_mode & MODE_LIST_OUTPUT) == MODE_LIST_OUTPUT)
+		data.list_outputs = true;
+
+	if (data.opt_output) {
+		if (regcomp(&out_port_regex, data.opt_output, REG_EXTENDED | REG_NOSUB) == 0)
+			data.out_regex = &out_port_regex;
+	}
+	if (data.opt_input) {
+		if (regcomp(&in_port_regex, data.opt_input, REG_EXTENDED | REG_NOSUB) == 0)
+			data.in_regex = &in_port_regex;
+	}
+
+	if (data.opt_mode & (MODE_LIST)) {
+		do_list(&data);
+	} else if (data.opt_mode & MODE_DISCONNECT) {
+		if (data.opt_output == NULL) {
+			fprintf(stderr, "missing link-id or output and input port names to disconnect\n");
+			return -1;
+		}
+		if ((res = do_unlink_ports(&data)) < 0) {
+			fprintf(stderr, "failed to unlink ports: %s\n", spa_strerror(res));
+			return -1;
+		}
+	} else {
+		if (data.opt_output == NULL ||
+		    data.opt_input == NULL) {
+			fprintf(stderr, "missing output and input port names to connect\n");
+			return -1;
+		}
+		if ((res = do_link_ports(&data)) < 0) {
+			fprintf(stderr, "failed to link ports: %s\n", spa_strerror(res));
+			return -1;
+		}
+	}
+
+	if (data.opt_mode & MODE_MONITOR) {
+		data.monitoring = true;
+		pw_main_loop_run(data.loop);
+		data.monitoring = false;
+	}
+
+	if (data.out_regex)
+		regfree(data.out_regex);
+	if (data.in_regex)
+		regfree(data.in_regex);
+	spa_hook_remove(&data.registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data.registry);
+	spa_hook_remove(&data.core_listener);
+	pw_core_disconnect(data.core);
+	pw_context_destroy(data.context);
+	pw_main_loop_destroy(data.loop);
+	pw_deinit();
+
+	return res;
+}
diff --git a/src/tools/pw-loopback.c b/src/tools/pw-loopback.c
new file mode 100644
index 0000000..5f39be6
--- /dev/null
+++ b/src/tools/pw-loopback.c
@@ -0,0 +1,284 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <getopt.h>
+#include <limits.h>
+#include <math.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/pod/builder.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/audio/raw.h>
+#include <spa/utils/json.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/impl.h>
+
+#define DEFAULT_RATE		48000
+#define DEFAULT_CHANNELS	2
+#define DEFAULT_CHANNEL_MAP	"[ FL, FR ]"
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	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;
+
+	uint32_t channels;
+	uint32_t latency;
+	float delay;
+
+	struct pw_properties *capture_props;
+	struct pw_properties *playback_props;
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static void module_destroy(void *data)
+{
+	struct data *d = data;
+	spa_hook_remove(&d->module_listener);
+	d->module = NULL;
+	pw_main_loop_quit(d->loop);
+}
+
+static const struct pw_impl_module_events module_events = {
+	PW_VERSION_IMPL_MODULE_EVENTS,
+	.destroy = module_destroy
+};
+
+
+static void show_help(struct data *data, const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options]\n"
+		"  -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"
+		"  -l, --latency                         Desired latency in ms\n"
+		"  -d, --delay                           Desired delay in float s\n"
+		"  -C  --capture                         Capture source to connect to (name or serial)\n"
+		"      --capture-props                   Capture stream properties\n"
+		"  -P  --playback                        Playback sink to connect to (name or serial)\n"
+		"      --playback-props                  Playback stream properties\n",
+		name,
+		data->opt_node_name,
+		data->opt_group_name,
+		data->channels,
+		data->opt_channel_map);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct pw_loop *l;
+	const char *opt_remote = NULL;
+	char cname[256], value[256];
+	char *args;
+	size_t size;
+	FILE *f;
+	static const struct option long_options[] = {
+		{ "help",		no_argument,		NULL, 'h' },
+		{ "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' },
+		{ "delay",		required_argument,	NULL, 'd' },
+		{ "capture",		required_argument,	NULL, 'C' },
+		{ "playback",		required_argument,	NULL, 'P' },
+		{ "capture-props",	required_argument,	NULL, 'i' },
+		{ "playback-props",	required_argument,	NULL, 'o' },
+		{ NULL, 0, NULL, 0}
+	};
+	int c, res = -1;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	data.channels = DEFAULT_CHANNELS;
+	data.opt_channel_map = DEFAULT_CHANNEL_MAP;
+	data.opt_group_name = pw_get_client_name();
+	if (snprintf(cname, sizeof(cname), "%s-%zd", argv[0], (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);
+	if (data.capture_props == NULL || data.playback_props == NULL) {
+		fprintf(stderr, "can't create properties: %m\n");
+		goto exit;
+	}
+
+	while ((c = getopt_long(argc, argv, "hVr:n:g:c:m:l:d:C:P:i:o:", 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 'n':
+			data.opt_node_name = optarg;
+			break;
+		case 'g':
+			data.opt_group_name = optarg;
+			break;
+		case 'c':
+			data.channels = atoi(optarg);
+			break;
+		case 'm':
+			data.opt_channel_map = optarg;
+			break;
+		case 'l':
+			data.latency = atoi(optarg) * DEFAULT_RATE / SPA_MSEC_PER_SEC;
+			break;
+		case 'd':
+			data.delay = atof(optarg);
+			break;
+		case 'C':
+			pw_properties_set(data.capture_props, PW_KEY_TARGET_OBJECT, optarg);
+			break;
+		case 'P':
+			pw_properties_set(data.playback_props, PW_KEY_TARGET_OBJECT, optarg);
+			break;
+		case 'i':
+			pw_properties_update_string(data.capture_props, optarg, strlen(optarg));
+			break;
+		case 'o':
+			pw_properties_update_string(data.playback_props, optarg, strlen(optarg));
+			break;
+		default:
+			show_help(&data, argv[0], true);
+			return -1;
+		}
+	}
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "can't create main loop: %m\n");
+		goto exit;
+	}
+
+	l = pw_main_loop_get_loop(data.loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data.context = pw_context_new(l, NULL, 0);
+	if (data.context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		goto exit;
+	}
+
+
+        if ((f = open_memstream(&args, &size)) == NULL) {
+		fprintf(stderr, "can't open memstream: %m\n");
+		goto exit;
+	}
+
+	fprintf(f, "{");
+
+	if (opt_remote != NULL)
+		fprintf(f, " remote.name = \"%s\"", opt_remote);
+	if (data.latency != 0)
+		fprintf(f, " node.latency = %u/%u", data.latency, DEFAULT_RATE);
+	if (data.delay != 0.0f)
+		fprintf(f, " target.delay.sec = %s",
+				spa_json_format_float(value, sizeof(value), data.delay));
+	if (data.channels != 0)
+		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);
+		pw_properties_set(data.playback_props, PW_KEY_NODE_GROUP, data.opt_group_name);
+	}
+
+	fprintf(f, " capture.props = {");
+	pw_properties_serialize_dict(f, &data.capture_props->dict, 0);
+	fprintf(f, " } playback.props = {");
+	pw_properties_serialize_dict(f, &data.playback_props->dict, 0);
+	fprintf(f, " } }");
+	fclose(f);
+
+	pw_log_info("loading module with %s", args);
+
+	data.module = pw_context_load_module(data.context,
+			"libpipewire-module-loopback", args,
+			NULL);
+	free(args);
+
+	if (data.module == NULL) {
+		fprintf(stderr, "can't load module: %m\n");
+		goto exit;
+	}
+
+	pw_impl_module_add_listener(data.module,
+			&data.module_listener, &module_events, &data);
+
+	pw_main_loop_run(data.loop);
+
+	res = 0;
+exit:
+	if (data.module)
+		pw_impl_module_destroy(data.module);
+	if (data.context)
+		pw_context_destroy(data.context);
+	if (data.loop)
+		pw_main_loop_destroy(data.loop);
+	pw_properties_free(data.capture_props);
+	pw_properties_free(data.playback_props);
+	pw_deinit();
+
+	return res;
+}
diff --git a/src/tools/pw-metadata.c b/src/tools/pw-metadata.c
new file mode 100644
index 0000000..768bd91
--- /dev/null
+++ b/src/tools/pw-metadata.c
@@ -0,0 +1,297 @@
+/* PipeWire
+ *
+ * Copyright © 2020 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 <stdio.h>
+#include <signal.h>
+#include <math.h>
+#include <getopt.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/utils/defs.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/filter.h>
+#include <pipewire/extensions/metadata.h>
+
+struct data {
+	struct pw_main_loop *loop;
+
+	const char *opt_remote;
+	const char *opt_name;
+	bool opt_monitor;
+	bool opt_delete;
+	uint32_t opt_id;
+	const char *opt_key;
+	const char *opt_value;
+	const char *opt_type;
+
+	struct pw_context *context;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct pw_metadata *metadata;
+	struct spa_hook metadata_listener;
+
+	int sync;
+};
+
+
+static int metadata_property(void *data, uint32_t id,
+		const char *key, const char *type, const char *value)
+{
+	struct data *d = data;
+
+	if ((d->opt_id == SPA_ID_INVALID || d->opt_id == id) &&
+	    (d->opt_key == NULL || spa_streq(d->opt_key, key))) {
+		if (key == NULL) {
+			printf("remove: id:%u all keys\n", id);
+		} else if (value == NULL) {
+			printf("remove: id:%u key:'%s'\n", id, key);
+		} else {
+			printf("update: id:%u key:'%s' value:'%s' type:'%s'\n", id, key, value, type);
+		}
+	}
+
+	return 0;
+}
+
+static const struct pw_metadata_events metadata_events = {
+	PW_VERSION_METADATA_EVENTS,
+	.property = metadata_property
+};
+
+static void registry_event_global(void *data, uint32_t id, uint32_t permissions,
+				  const char *type, uint32_t version,
+				  const struct spa_dict *props)
+{
+	struct data *d = data;
+	const char *str;
+
+	if (!spa_streq(type, PW_TYPE_INTERFACE_Metadata))
+		return;
+
+	if (props != NULL &&
+	    (str = spa_dict_lookup(props, PW_KEY_METADATA_NAME)) != NULL &&
+	    !spa_streq(str, d->opt_name))
+		return;
+
+	if (d->metadata != NULL) {
+		pw_log_warn("Multiple metadata: ignoring metadata %d", id);
+		return;
+	}
+
+	printf("Found \"%s\" metadata %d\n", d->opt_name, id);
+	d->metadata = pw_registry_bind(d->registry,
+			id, type, PW_VERSION_METADATA, 0);
+
+	if (d->opt_delete) {
+		if (d->opt_id != SPA_ID_INVALID) {
+			if (d->opt_key != NULL)
+				printf("delete property: id:%u key:%s\n", d->opt_id, d->opt_key);
+			else
+				printf("delete properties: id:%u\n", d->opt_id);
+			pw_metadata_set_property(d->metadata, d->opt_id, d->opt_key, NULL, NULL);
+		} else {
+			printf("delete all properties\n");
+			pw_metadata_clear(d->metadata);
+		}
+	} else if (d->opt_id != SPA_ID_INVALID && d->opt_key != NULL && d->opt_value != NULL) {
+		printf("set property: id:%u key:%s value:%s type:%s\n",
+				d->opt_id, d->opt_key, d->opt_value, d->opt_type);
+		pw_metadata_set_property(d->metadata, d->opt_id, d->opt_key, d->opt_type, d->opt_value);
+	} else {
+		pw_metadata_add_listener(d->metadata,
+				&d->metadata_listener,
+				&metadata_events, d);
+	}
+
+	d->sync = pw_core_sync(d->core, PW_ID_CORE, d->sync);
+}
+
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+};
+
+static void on_core_done(void *data, uint32_t id, int seq)
+{
+	struct data *d = data;
+	if (d->sync == seq && !d->opt_monitor)
+		pw_main_loop_quit(d->loop);
+}
+
+static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
+{
+	struct 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)
+		pw_main_loop_quit(d->loop);
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.done = on_core_done,
+	.error = on_core_error,
+};
+
+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 error)
+{
+        fprintf(error ? stderr : stdout, "%s [options] [ id [ key [ value [ type ] ] ] ]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote                          Remote daemon name\n"
+		"  -m, --monitor                         Monitor metadata\n"
+		"  -d, --delete                          Delete metadata\n"
+		"  -n, --name                            Metadata name (default: \"%s\")\n",
+		name, data->opt_name);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0, };
+	int res = 0, c;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ "monitor",	no_argument,		NULL, 'm' },
+		{ "delete",	no_argument,		NULL, 'd' },
+		{ "name",	required_argument,	NULL, 'n' },
+		{ NULL,	0, NULL, 0}
+	};
+
+	setlinebuf(stdout);
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	data.opt_name = "default";
+
+	while ((c = getopt_long(argc, argv, "hVr:mdn:", 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':
+			data.opt_remote = optarg;
+			break;
+		case 'm':
+			data.opt_monitor = true;
+			break;
+		case 'd':
+			data.opt_delete = true;
+			break;
+		case 'n':
+			data.opt_name = optarg;
+			break;
+		default:
+			show_help(&data, argv[0], true);
+			return -1;
+		}
+	}
+
+	data.opt_id = SPA_ID_INVALID;
+	if (optind < argc)
+		data.opt_id = atoi(argv[optind++]);
+	if (optind < argc)
+		data.opt_key = argv[optind++];
+	if (optind < argc)
+		data.opt_value = argv[optind++];
+	if (optind < argc)
+		data.opt_type = argv[optind++];
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "can't create mainloop: %m\n");
+		return -1;
+	}
+	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);
+
+	data.context = pw_context_new(pw_main_loop_get_loop(data.loop), NULL, 0);
+	if (data.context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		return -1;
+	}
+
+	data.core = pw_context_connect(data.context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, data.opt_remote,
+				NULL),
+			0);
+	if (data.core == NULL) {
+		fprintf(stderr, "can't connect: %m\n");
+		return -1;
+	}
+
+	pw_core_add_listener(data.core,
+			&data.core_listener,
+			&core_events, &data);
+
+	data.registry = pw_core_get_registry(data.core,
+			PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data.registry,
+			&data.registry_listener,
+			&registry_events, &data);
+
+	data.sync = pw_core_sync(data.core, PW_ID_CORE, data.sync);
+
+	pw_main_loop_run(data.loop);
+
+	if (data.metadata)
+		pw_proxy_destroy((struct pw_proxy*)data.metadata);
+	spa_hook_remove(&data.registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data.registry);
+	spa_hook_remove(&data.core_listener);
+	pw_core_disconnect(data.core);
+	pw_context_destroy(data.context);
+	pw_main_loop_destroy(data.loop);
+	pw_deinit();
+
+	return res;
+}
diff --git a/src/tools/pw-mididump.c b/src/tools/pw-mididump.c
new file mode 100644
index 0000000..d6b803f
--- /dev/null
+++ b/src/tools/pw-mididump.c
@@ -0,0 +1,233 @@
+/* PipeWire
+ *
+ * Copyright © 2020 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 <stdio.h>
+#include <signal.h>
+#include <math.h>
+#include <getopt.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/defs.h>
+#include <spa/control/control.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/props.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/filter.h>
+
+#include "midifile.h"
+
+struct data;
+
+struct port {
+	struct data *data;
+};
+
+struct data {
+	struct pw_main_loop *loop;
+	const char *opt_remote;
+	struct pw_filter *filter;
+	struct port *in_port;
+	int64_t clock_time;
+};
+
+static int dump_file(const char *filename)
+{
+	struct midi_file *file;
+	struct midi_file_info info;
+	struct midi_event ev;
+
+	file = midi_file_open(filename, "r", &info);
+	if (file == NULL) {
+		fprintf(stderr, "error opening %s: %m\n", filename);
+		return -1;
+	}
+
+	printf("opened %s\n", filename);
+
+	while (midi_file_read_event(file, &ev) == 1) {
+		midi_file_dump_event(stdout, &ev);
+	}
+	midi_file_close(file);
+
+	return 0;
+}
+
+static void on_process(void *_data, struct spa_io_position *position)
+{
+	struct data *data = _data;
+	struct pw_buffer *b;
+	struct spa_buffer *buf;
+	struct spa_data *d;
+	struct spa_pod *pod;
+	struct spa_pod_control *c;
+	uint64_t frame;
+
+	frame = data->clock_time;
+	data->clock_time += position->clock.duration;
+
+	b = pw_filter_dequeue_buffer(data->in_port);
+	if (b == NULL)
+		return;
+
+	buf = b->buffer;
+	d = &buf->datas[0];
+
+	if (d->data == NULL)
+		return;
+
+	if ((pod = spa_pod_from_data(d->data, d->maxsize, d->chunk->offset, d->chunk->size)) == NULL)
+		return;
+	if (!spa_pod_is_sequence(pod))
+		return;
+
+	SPA_POD_SEQUENCE_FOREACH((struct spa_pod_sequence*)pod, c) {
+		struct midi_event ev;
+
+		if (c->type != SPA_CONTROL_Midi)
+			continue;
+
+		ev.track = 0;
+		ev.sec = (frame + c->offset) / (float) position->clock.rate.denom;
+		ev.data = SPA_POD_BODY(&c->value),
+		ev.size = SPA_POD_BODY_SIZE(&c->value);
+
+		printf("%4d: ", c->offset);
+		midi_file_dump_event(stdout, &ev);
+	}
+
+	pw_filter_queue_buffer(data->in_port, b);
+}
+
+static const struct pw_filter_events filter_events = {
+	PW_VERSION_FILTER_EVENTS,
+	.process = on_process,
+};
+
+static void do_quit(void *userdata, int signal_number)
+{
+	struct data *data = userdata;
+	pw_main_loop_quit(data->loop);
+}
+
+static int dump_filter(struct data *data)
+{
+	data->loop = pw_main_loop_new(NULL);
+	if (data->loop == NULL)
+		return -errno;
+
+	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);
+
+	data->filter = pw_filter_new_simple(
+			pw_main_loop_get_loop(data->loop),
+			"midi-dump",
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, data->opt_remote,
+				PW_KEY_MEDIA_TYPE, "Midi",
+				PW_KEY_MEDIA_CATEGORY, "Filter",
+				PW_KEY_MEDIA_ROLE, "DSP",
+				NULL),
+			&filter_events,
+			data);
+
+	data->in_port = pw_filter_add_port(data->filter,
+			PW_DIRECTION_INPUT,
+			PW_FILTER_PORT_FLAG_MAP_BUFFERS,
+			sizeof(struct port),
+			pw_properties_new(
+				PW_KEY_FORMAT_DSP, "8 bit raw midi",
+				PW_KEY_PORT_NAME, "input",
+				NULL),
+			NULL, 0);
+
+	if (pw_filter_connect(data->filter, PW_FILTER_FLAG_RT_PROCESS, NULL, 0) < 0) {
+		fprintf(stderr, "can't connect\n");
+		return -1;
+	}
+
+	pw_main_loop_run(data->loop);
+
+	pw_filter_destroy(data->filter);
+	pw_main_loop_destroy(data->loop);
+
+	return 0;
+}
+
+static void show_help(const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options] [FILE]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote                          Remote daemon name\n",
+		name);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0, };
+	int res = 0, c;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ NULL,	0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	setlinebuf(stdout);
+
+	while ((c = getopt_long(argc, argv, "hVr:", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h':
+			show_help(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':
+			data.opt_remote = optarg;
+			break;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+
+	if (optind < argc) {
+		res = dump_file(argv[optind]);
+	} else {
+		res = dump_filter(&data);
+	}
+	pw_deinit();
+	return res;
+}
diff --git a/src/tools/pw-mon.c b/src/tools/pw-mon.c
new file mode 100644
index 0000000..2eeb4dd
--- /dev/null
+++ b/src/tools/pw-mon.c
@@ -0,0 +1,875 @@
+/* PipeWire
+ *
+ * Copyright © 2018 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 <stdio.h>
+#include <signal.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/utils/ansi.h>
+#include <spa/debug/pod.h>
+#include <spa/debug/format.h>
+#include <spa/debug/types.h>
+
+#include <pipewire/pipewire.h>
+
+struct proxy_data;
+
+typedef void (*print_func_t) (struct proxy_data *data);
+
+static struct pprefix {
+	const char *prefix;
+	const char *suffix;
+} pprefix[2] = {
+	{ .prefix = " ", .suffix = "" },
+	{ .prefix = "*", .suffix = "" },
+};
+
+#define with_prefix(use_prefix_) \
+   for (bool once_ = !!printf("%s", (pprefix[!!(use_prefix_)]).prefix); \
+	once_; \
+	once_ = false, printf("%s", (pprefix[!!(use_prefix_)]).suffix))
+
+
+struct param {
+	struct spa_list link;
+	uint32_t id;
+	int seq;
+	struct spa_pod *param;
+	unsigned int changed:1;
+};
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct spa_list pending_list;
+	struct spa_list global_list;
+};
+
+struct proxy_data {
+	struct data *data;
+	bool first;
+	struct pw_proxy *proxy;
+	uint32_t id;
+	uint32_t permissions;
+	uint32_t version;
+	char *type;
+	void *info;
+	pw_destroy_t destroy;
+	struct spa_hook proxy_listener;
+	struct spa_hook object_listener;
+	int pending_seq;
+	struct spa_list global_link;
+	struct spa_list pending_link;
+	print_func_t print_func;
+	struct spa_list param_list;
+};
+
+static void add_pending(struct proxy_data *pd)
+{
+	struct data *d = pd->data;
+
+	if (pd->pending_seq == 0) {
+		spa_list_append(&d->pending_list, &pd->pending_link);
+	}
+	pd->pending_seq = pw_core_sync(d->core, 0, pd->pending_seq);
+}
+
+static void remove_pending(struct proxy_data *pd)
+{
+	if (pd->pending_seq != 0) {
+		spa_list_remove(&pd->pending_link);
+		pd->pending_seq = 0;
+	}
+}
+
+static void on_core_done(void *data, uint32_t id, int seq)
+{
+	struct data *d = data;
+	struct proxy_data *pd, *t;
+
+	spa_list_for_each_safe(pd, t, &d->pending_list, pending_link) {
+		if (pd->pending_seq == seq) {
+			remove_pending(pd);
+			pd->print_func(pd);
+		}
+	}
+}
+
+static void clear_params(struct proxy_data *data)
+{
+	struct param *p;
+	spa_list_consume(p, &data->param_list, link) {
+		spa_list_remove(&p->link);
+		free(p);
+	}
+}
+
+static void remove_params(struct proxy_data *data, uint32_t id, int seq)
+{
+	struct param *p, *t;
+
+	spa_list_for_each_safe(p, t, &data->param_list, link) {
+		if (p->id == id && seq != p->seq) {
+			spa_list_remove(&p->link);
+			free(p);
+		}
+	}
+}
+
+static void event_param(void *_data, int seq, uint32_t id,
+		uint32_t index, uint32_t next, const struct spa_pod *param)
+{
+        struct proxy_data *data = _data;
+	struct param *p;
+
+	/* remove all params with the same id and older seq */
+	remove_params(data, id, seq);
+
+	/* add new param */
+	p = malloc(sizeof(struct param) + SPA_POD_SIZE(param));
+	if (p == NULL) {
+		pw_log_error("can't add param: %m");
+		return;
+	}
+
+	p->id = id;
+	p->seq = seq;
+	p->param = SPA_PTROFF(p, sizeof(struct param), struct spa_pod);
+	p->changed = true;
+	memcpy(p->param, param, SPA_POD_SIZE(param));
+	spa_list_append(&data->param_list, &p->link);
+}
+
+static void print_params(struct proxy_data *data, bool use_prefix)
+{
+	struct param *p;
+
+	with_prefix(use_prefix) {
+		printf("\tparams:\n");
+	}
+
+	spa_list_for_each(p, &data->param_list, link) {
+		with_prefix(p->changed) {
+			printf("\t  id:%u (%s)\n",
+				p->id,
+				spa_debug_type_find_name(spa_type_param, p->id));
+			if (spa_pod_is_object_type(p->param, SPA_TYPE_OBJECT_Format))
+				spa_debug_format(10, NULL, p->param);
+			else
+				spa_debug_pod(10, NULL, p->param);
+		}
+		p->changed = false;
+	}
+}
+
+static void print_properties(const struct spa_dict *props, bool use_prefix)
+{
+	const struct spa_dict_item *item;
+
+	with_prefix(use_prefix) {
+		printf("\tproperties:\n");
+		if (props == NULL || props->n_items == 0) {
+			printf("\t\tnone\n");
+			return;
+		}
+	}
+
+	spa_dict_for_each(item, props) {
+		with_prefix(use_prefix) {
+			if (item->value)
+				printf("\t\t%s = \"%s\"\n", item->key, item->value);
+			else
+				printf("\t\t%s = (null)\n", item->key);
+		}
+	}
+}
+
+#define MARK_CHANGE(f) (!!(print_mark && ((info)->change_mask & (f))))
+
+static void on_core_info(void *data, const struct pw_core_info *info)
+{
+	bool print_all = true, print_mark = true;
+
+	printf("\ttype: %s\n", PW_TYPE_INTERFACE_Core);
+	printf("\tcookie: %u\n", info->cookie);
+	printf("\tuser-name: \"%s\"\n", info->user_name);
+	printf("\thost-name: \"%s\"\n", info->host_name);
+	printf("\tversion: \"%s\"\n", info->version);
+	printf("\tname: \"%s\"\n", info->name);
+	if (print_all) {
+		print_properties(info->props, MARK_CHANGE(PW_CORE_CHANGE_MASK_PROPS));
+	}
+}
+
+static void module_event_info(void *_data, const struct pw_module_info *info)
+{
+        struct proxy_data *data = _data;
+	bool print_all, print_mark;
+
+	print_all = true;
+        if (data->info == NULL) {
+		printf("added:\n");
+		print_mark = false;
+	}
+        else {
+		printf("changed:\n");
+		print_mark = true;
+	}
+
+	info = data->info = pw_module_info_update(data->info, info);
+
+	printf("\tid: %d\n", data->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(data->permissions));
+	printf("\ttype: %s (version %d)\n", data->type, data->version);
+	printf("\tname: \"%s\"\n", info->name);
+	printf("\tfilename: \"%s\"\n", info->filename);
+	printf("\targs: \"%s\"\n", info->args);
+	if (print_all) {
+		print_properties(info->props, MARK_CHANGE(PW_MODULE_CHANGE_MASK_PROPS));
+	}
+}
+
+static const struct pw_module_events module_events = {
+	PW_VERSION_MODULE_EVENTS,
+        .info = module_event_info,
+};
+
+static void print_node(struct proxy_data *data)
+{
+	struct pw_node_info *info = data->info;
+	bool print_all, print_mark;
+
+	print_all = true;
+        if (data->first) {
+		printf("added:\n");
+		print_mark = false;
+		data->first = false;
+	}
+        else {
+		printf("changed:\n");
+		print_mark = true;
+	}
+
+	printf("\tid: %d\n", data->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(data->permissions));
+	printf("\ttype: %s (version %d)\n", data->type, data->version);
+	if (print_all) {
+		print_params(data, MARK_CHANGE(PW_NODE_CHANGE_MASK_PARAMS));
+		with_prefix(MARK_CHANGE(PW_NODE_CHANGE_MASK_INPUT_PORTS)) {
+			printf("\tinput ports: %u/%u\n",
+				info->n_input_ports, info->max_input_ports);
+		}
+		with_prefix(MARK_CHANGE(PW_NODE_CHANGE_MASK_OUTPUT_PORTS)) {
+			printf("\toutput ports: %u/%u\n",
+				info->n_output_ports, info->max_output_ports);
+		}
+		with_prefix(MARK_CHANGE(PW_NODE_CHANGE_MASK_STATE)) {
+			printf("\tstate: \"%s\"",
+				pw_node_state_as_string(info->state));
+		}
+		if (info->state == PW_NODE_STATE_ERROR && info->error)
+			printf(" \"%s\"\n", info->error);
+		else
+			printf("\n");
+		print_properties(info->props, MARK_CHANGE(PW_NODE_CHANGE_MASK_PROPS));
+	}
+}
+
+static void node_event_info(void *_data, const struct pw_node_info *info)
+{
+        struct proxy_data *data = _data;
+	uint32_t i;
+
+	info = data->info = pw_node_info_update(data->info, info);
+
+	if (info->change_mask & PW_NODE_CHANGE_MASK_PARAMS) {
+		for (i = 0; i < info->n_params; i++) {
+			if (info->params[i].user == 0)
+				continue;
+			remove_params(data, info->params[i].id, 0);
+			if (!SPA_FLAG_IS_SET(info->params[i].flags, SPA_PARAM_INFO_READ))
+				continue;
+			pw_node_enum_params((struct pw_node*)data->proxy,
+					0, info->params[i].id, 0, 0, NULL);
+			info->params[i].user = 0;
+		}
+		add_pending(data);
+	}
+
+	if (data->pending_seq == 0)
+		data->print_func(data);
+}
+
+static const struct pw_node_events node_events = {
+	PW_VERSION_NODE_EVENTS,
+        .info = node_event_info,
+        .param = event_param
+};
+
+static void print_port(struct proxy_data *data)
+{
+	struct pw_port_info *info = data->info;
+	bool print_all, print_mark;
+
+	print_all = true;
+        if (data->first) {
+		printf("added:\n");
+		print_mark = false;
+		data->first = false;
+	}
+        else {
+		printf("changed:\n");
+		print_mark = true;
+	}
+
+	printf("\tid: %d\n", data->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(data->permissions));
+	printf("\ttype: %s (version %d)\n", data->type, data->version);
+
+	printf("\tdirection: \"%s\"\n", pw_direction_as_string(info->direction));
+	if (print_all) {
+		print_params(data, MARK_CHANGE(PW_PORT_CHANGE_MASK_PARAMS));
+		print_properties(info->props, MARK_CHANGE(PW_PORT_CHANGE_MASK_PROPS));
+	}
+}
+
+static void port_event_info(void *_data, const struct pw_port_info *info)
+{
+        struct proxy_data *data = _data;
+	uint32_t i;
+
+	info = data->info = pw_port_info_update(data->info, info);
+
+	if (info->change_mask & PW_PORT_CHANGE_MASK_PARAMS) {
+		for (i = 0; i < info->n_params; i++) {
+			if (info->params[i].user == 0)
+				continue;
+			remove_params(data, info->params[i].id, 0);
+			if (!SPA_FLAG_IS_SET(info->params[i].flags, SPA_PARAM_INFO_READ))
+				continue;
+			pw_port_enum_params((struct pw_port*)data->proxy,
+					0, info->params[i].id, 0, 0, NULL);
+			info->params[i].user = 0;
+		}
+		add_pending(data);
+	}
+
+	if (data->pending_seq == 0)
+		data->print_func(data);
+}
+
+static const struct pw_port_events port_events = {
+	PW_VERSION_PORT_EVENTS,
+        .info = port_event_info,
+        .param = event_param
+};
+
+static void factory_event_info(void *_data, const struct pw_factory_info *info)
+{
+        struct proxy_data *data = _data;
+	bool print_all, print_mark;
+
+	print_all = true;
+        if (data->info == NULL) {
+		printf("added:\n");
+		print_mark = false;
+	}
+        else {
+		printf("changed:\n");
+		print_mark = true;
+	}
+
+        info = data->info = pw_factory_info_update(data->info, info);
+
+	printf("\tid: %d\n", data->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(data->permissions));
+	printf("\ttype: %s (version %d)\n", data->type, data->version);
+
+	printf("\tname: \"%s\"\n", info->name);
+	printf("\tobject-type: %s/%d\n", info->type, info->version);
+	if (print_all) {
+		print_properties(info->props, MARK_CHANGE(PW_FACTORY_CHANGE_MASK_PROPS));
+	}
+}
+
+static const struct pw_factory_events factory_events = {
+	PW_VERSION_FACTORY_EVENTS,
+        .info = factory_event_info
+};
+
+static void client_event_info(void *_data, const struct pw_client_info *info)
+{
+        struct proxy_data *data = _data;
+	bool print_all, print_mark;
+
+	print_all = true;
+        if (data->info == NULL) {
+		printf("added:\n");
+		print_mark = false;
+	}
+        else {
+		printf("changed:\n");
+		print_mark = true;
+	}
+
+        info = data->info = pw_client_info_update(data->info, info);
+
+	printf("\tid: %d\n", data->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(data->permissions));
+	printf("\ttype: %s (version %d)\n", data->type, data->version);
+
+	if (print_all) {
+		print_properties(info->props, MARK_CHANGE(PW_CLIENT_CHANGE_MASK_PROPS));
+	}
+}
+
+static const struct pw_client_events client_events = {
+	PW_VERSION_CLIENT_EVENTS,
+        .info = client_event_info
+};
+
+static void link_event_info(void *_data, const struct pw_link_info *info)
+{
+        struct proxy_data *data = _data;
+	bool print_all, print_mark;
+
+	print_all = true;
+        if (data->info == NULL) {
+		printf("added:\n");
+		print_mark = false;
+	}
+        else {
+		printf("changed:\n");
+		print_mark = true;
+	}
+
+        info = data->info = pw_link_info_update(data->info, info);
+
+	printf("\tid: %d\n", data->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(data->permissions));
+	printf("\ttype: %s (version %d)\n", data->type, data->version);
+
+	printf("\toutput-node-id: %u\n", info->output_node_id);
+	printf("\toutput-port-id: %u\n", info->output_port_id);
+	printf("\tinput-node-id: %u\n", info->input_node_id);
+	printf("\tinput-port-id: %u\n", info->input_port_id);
+	if (print_all) {
+		with_prefix(MARK_CHANGE(PW_LINK_CHANGE_MASK_STATE)) {
+			printf("\tstate: \"%s\"",
+				pw_link_state_as_string(info->state));
+		}
+		if (info->state == PW_LINK_STATE_ERROR && info->error)
+			printf(" \"%s\"\n", info->error);
+		else
+			printf("\n");
+		with_prefix(MARK_CHANGE(PW_LINK_CHANGE_MASK_FORMAT)) {
+			printf("\tformat:\n");
+			if (info->format)
+				spa_debug_format(2, NULL, info->format);
+			else
+				printf("\t\tnone\n");
+		}
+		print_properties(info->props, MARK_CHANGE(PW_LINK_CHANGE_MASK_PROPS));
+	}
+}
+
+static const struct pw_link_events link_events = {
+	PW_VERSION_LINK_EVENTS,
+	.info = link_event_info
+};
+
+static void print_device(struct proxy_data *data)
+{
+	struct pw_device_info *info = data->info;
+	bool print_all, print_mark;
+
+	print_all = true;
+        if (data->first) {
+		printf("added:\n");
+		print_mark = false;
+		data->first = false;
+	}
+        else {
+		printf("changed:\n");
+		print_mark = true;
+	}
+
+	printf("\tid: %d\n", data->id);
+	printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+			PW_PERMISSION_ARGS(data->permissions));
+	printf("\ttype: %s (version %d)\n", data->type, data->version);
+
+	if (print_all) {
+		print_params(data, MARK_CHANGE(PW_DEVICE_CHANGE_MASK_PARAMS));
+		print_properties(info->props, MARK_CHANGE(PW_DEVICE_CHANGE_MASK_PROPS));
+	}
+}
+
+
+static void device_event_info(void *_data, const struct pw_device_info *info)
+{
+        struct proxy_data *data = _data;
+	uint32_t i;
+
+	info = data->info = pw_device_info_update(data->info, info);
+
+	if (info->change_mask & PW_DEVICE_CHANGE_MASK_PARAMS) {
+		for (i = 0; i < info->n_params; i++) {
+			if (info->params[i].user == 0)
+				continue;
+			remove_params(data, info->params[i].id, 0);
+			if (!SPA_FLAG_IS_SET(info->params[i].flags, SPA_PARAM_INFO_READ))
+				continue;
+			pw_device_enum_params((struct pw_device*)data->proxy,
+					0, info->params[i].id, 0, 0, NULL);
+			info->params[i].user = 0;
+		}
+		add_pending(data);
+	}
+	if (data->pending_seq == 0)
+		data->print_func(data);
+}
+
+static const struct pw_device_events device_events = {
+	PW_VERSION_DEVICE_EVENTS,
+	.info = device_event_info,
+        .param = event_param
+};
+
+static void
+removed_proxy (void *data)
+{
+        struct proxy_data *pd = data;
+	pw_proxy_destroy(pd->proxy);
+}
+
+static void
+destroy_proxy (void *data)
+{
+	struct proxy_data *pd = data;
+
+	spa_list_remove(&pd->global_link);
+
+	spa_hook_remove(&pd->object_listener);
+	spa_hook_remove(&pd->proxy_listener);
+
+	clear_params(pd);
+	remove_pending(pd);
+	free(pd->type);
+
+	if (pd->info == NULL)
+		return;
+	if (pd->destroy)
+		pd->destroy(pd->info);
+	pd->info = NULL;
+}
+
+static const struct pw_proxy_events proxy_events = {
+	PW_VERSION_PROXY_EVENTS,
+	.removed = removed_proxy,
+	.destroy = destroy_proxy,
+};
+
+static void registry_event_global(void *data, uint32_t id,
+				  uint32_t permissions, const char *type, uint32_t version,
+				  const struct spa_dict *props)
+{
+	struct data *d = data;
+	struct pw_proxy *proxy;
+	uint32_t client_version;
+	const void *events;
+	struct proxy_data *pd;
+	pw_destroy_t destroy;
+	print_func_t print_func = NULL;
+
+	if (spa_streq(type, PW_TYPE_INTERFACE_Node)) {
+		events = &node_events;
+		client_version = PW_VERSION_NODE;
+		destroy = (pw_destroy_t) pw_node_info_free;
+		print_func = print_node;
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Port)) {
+		events = &port_events;
+		client_version = PW_VERSION_PORT;
+		destroy = (pw_destroy_t) pw_port_info_free;
+		print_func = print_port;
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Module)) {
+		events = &module_events;
+		client_version = PW_VERSION_MODULE;
+		destroy = (pw_destroy_t) pw_module_info_free;
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Device)) {
+		events = &device_events;
+		client_version = PW_VERSION_DEVICE;
+		destroy = (pw_destroy_t) pw_device_info_free;
+		print_func = print_device;
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Factory)) {
+		events = &factory_events;
+		client_version = PW_VERSION_FACTORY;
+		destroy = (pw_destroy_t) pw_factory_info_free;
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Client)) {
+		events = &client_events;
+		client_version = PW_VERSION_CLIENT;
+		destroy = (pw_destroy_t) pw_client_info_free;
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Link)) {
+		events = &link_events;
+		client_version = PW_VERSION_LINK;
+		destroy = (pw_destroy_t) pw_link_info_free;
+	} else {
+		printf("added:\n");
+		printf("\tid: %u\n", id);
+		printf("\tpermissions: "PW_PERMISSION_FORMAT"\n",
+				PW_PERMISSION_ARGS(permissions));
+		printf("\ttype: %s (version %d)\n", type, version);
+		print_properties(props, false);
+		return;
+	}
+
+	proxy = pw_registry_bind(d->registry, id, type,
+				       client_version,
+				       sizeof(struct proxy_data));
+	if (proxy == NULL)
+		goto no_mem;
+
+	pd = pw_proxy_get_user_data(proxy);
+	pd->data = d;
+	pd->first = true;
+	pd->proxy = proxy;
+	pd->id = id;
+	pd->permissions = permissions;
+	pd->version = version;
+	pd->type = strdup(type);
+	pd->destroy = destroy;
+	pd->pending_seq = 0;
+	pd->print_func = print_func;
+	spa_list_init(&pd->param_list);
+	pw_proxy_add_object_listener(proxy, &pd->object_listener, events, pd);
+	pw_proxy_add_listener(proxy, &pd->proxy_listener, &proxy_events, pd);
+	spa_list_append(&d->global_list, &pd->global_link);
+
+	return;
+
+no_mem:
+	fprintf(stderr, "failed to create proxy");
+	return;
+}
+
+static struct proxy_data *find_proxy(struct data *d, uint32_t id)
+{
+	struct proxy_data *pd;
+	spa_list_for_each(pd, &d->global_list, global_link) {
+		if (pd->id == id)
+			return pd;
+	}
+	return NULL;
+}
+
+static void registry_event_global_remove(void *data, uint32_t id)
+{
+	struct data *d = data;
+	struct proxy_data *pd;
+
+	printf("removed:\n");
+	printf("\tid: %u\n", id);
+
+	pd = find_proxy(d, id);
+	if (pd == NULL)
+		return;
+	if (pd->proxy)
+		pw_proxy_destroy(pd->proxy);
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+	.global_remove = registry_event_global_remove,
+};
+
+static void on_core_error(void *_data, uint32_t id, int seq, int res, const char *message)
+{
+	struct data *data = _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_main_loop_quit(data->loop);
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.info = on_core_info,
+	.done = on_core_done,
+	.error = on_core_error,
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static void show_help(const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote                          Remote daemon name\n"
+		"  -N, --no-colors                       disable color output\n"
+		"  -C, --color[=WHEN]                    whether to enable color support. WHEN is `never`, `always`, or `auto`\n",
+		name);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct pw_loop *l;
+	const char *opt_remote = NULL;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ "no-colors",	no_argument,		NULL, 'N' },
+		{ "color",	optional_argument,	NULL, 'C' },
+		{ NULL,	0, NULL, 0}
+	};
+	int c;
+	bool colors = false;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	setlinebuf(stdout);
+
+	if (isatty(STDERR_FILENO) && getenv("NO_COLOR") == NULL)
+		colors = true;
+
+	while ((c = getopt_long(argc, argv, "hVr:NC", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h':
+			show_help(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 'N' :
+			colors = false;
+			break;
+		case 'C' :
+			if (optarg == NULL || !strcmp(optarg, "auto"))
+				break; /* nothing to do, tty detection was done
+					  before parsing options */
+			else if (!strcmp(optarg, "never"))
+				colors = false;
+			else if (!strcmp(optarg, "always"))
+				colors = true;
+			else {
+				fprintf(stderr, "Invalid color: %s\n", optarg);
+				show_help(argv[0], true);
+				return -1;
+			}
+			break;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+
+	if (colors) {
+		pprefix[1].prefix = SPA_ANSI_RED "*";
+		pprefix[1].suffix = SPA_ANSI_RESET;
+	}
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "can't create main loop: %m\n");
+		return -1;
+	}
+
+	l = pw_main_loop_get_loop(data.loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data.context = pw_context_new(l, NULL, 0);
+	if (data.context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		return -1;
+	}
+
+	spa_list_init(&data.pending_list);
+	spa_list_init(&data.global_list);
+
+	data.core = pw_context_connect(data.context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, opt_remote,
+				NULL),
+			0);
+	if (data.core == NULL) {
+		fprintf(stderr, "can't connect: %m\n");
+		return -1;
+	}
+
+	pw_core_add_listener(data.core,
+				   &data.core_listener,
+				   &core_events, &data);
+	data.registry = pw_core_get_registry(data.core,
+					  PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data.registry,
+				       &data.registry_listener,
+				       &registry_events, &data);
+
+	pw_main_loop_run(data.loop);
+
+	spa_hook_remove(&data.registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data.registry);
+	spa_hook_remove(&data.core_listener);
+	pw_context_destroy(data.context);
+	pw_main_loop_destroy(data.loop);
+	pw_deinit();
+
+	return 0;
+}
diff --git a/src/tools/pw-profiler.c b/src/tools/pw-profiler.c
new file mode 100644
index 0000000..7ee85bb
--- /dev/null
+++ b/src/tools/pw-profiler.c
@@ -0,0 +1,665 @@
+/* PipeWire
+ *
+ * Copyright © 2020 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 <stdio.h>
+#include <signal.h>
+#include <getopt.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/pod/parser.h>
+#include <spa/debug/types.h>
+
+#include <pipewire/impl.h>
+#include <pipewire/extensions/profiler.h>
+
+#define MAX_NAME		128
+#define MAX_FOLLOWERS		64
+#define DEFAULT_FILENAME	"profiler.log"
+
+struct follower {
+	uint32_t id;
+	char name[MAX_NAME];
+};
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	const char *filename;
+	FILE *output;
+
+	int64_t count;
+	int64_t start_status;
+	int64_t last_status;
+
+	struct pw_proxy *profiler;
+	struct spa_hook profiler_listener;
+	int check_profiler;
+
+	uint32_t driver_id;
+
+	int n_followers;
+	struct follower followers[MAX_FOLLOWERS];
+};
+
+struct measurement {
+	int64_t period;
+	int64_t prev_signal;
+	int64_t signal;
+	int64_t awake;
+	int64_t finish;
+	int32_t status;
+};
+
+struct point {
+	int64_t count;
+	float cpu_load[3];
+	struct spa_io_clock clock;
+	struct measurement driver;
+	struct measurement follower[MAX_FOLLOWERS];
+};
+
+static int process_info(struct data *d, const struct spa_pod *pod, struct point *point)
+{
+	return spa_pod_parse_struct(pod,
+			SPA_POD_Long(&point->count),
+			SPA_POD_Float(&point->cpu_load[0]),
+			SPA_POD_Float(&point->cpu_load[1]),
+			SPA_POD_Float(&point->cpu_load[2]));
+}
+
+static int process_clock(struct data *d, const struct spa_pod *pod, struct point *point)
+{
+	return spa_pod_parse_struct(pod,
+			SPA_POD_Int(&point->clock.flags),
+			SPA_POD_Int(&point->clock.id),
+			SPA_POD_Stringn(point->clock.name, sizeof(point->clock.name)),
+			SPA_POD_Long(&point->clock.nsec),
+			SPA_POD_Fraction(&point->clock.rate),
+			SPA_POD_Long(&point->clock.position),
+			SPA_POD_Long(&point->clock.duration),
+			SPA_POD_Long(&point->clock.delay),
+			SPA_POD_Double(&point->clock.rate_diff),
+			SPA_POD_Long(&point->clock.next_nsec));
+}
+
+static int process_driver_block(struct data *d, const struct spa_pod *pod, struct point *point)
+{
+	char *name = NULL;
+	uint32_t driver_id = 0;
+	struct measurement driver;
+	int res;
+
+	spa_zero(driver);
+	if ((res = spa_pod_parse_struct(pod,
+			SPA_POD_Int(&driver_id),
+			SPA_POD_String(&name),
+			SPA_POD_Long(&driver.prev_signal),
+			SPA_POD_Long(&driver.signal),
+			SPA_POD_Long(&driver.awake),
+			SPA_POD_Long(&driver.finish),
+			SPA_POD_Int(&driver.status))) < 0)
+		return res;
+
+	if (d->driver_id == 0) {
+		d->driver_id = driver_id;
+		printf("logging driver %u\n", driver_id);
+	}
+	else if (d->driver_id != driver_id)
+		return -1;
+
+	point->driver = driver;
+	return 0;
+}
+
+static int find_follower(struct data *d, uint32_t id, const char *name)
+{
+	int i;
+	for (i = 0; i < d->n_followers; i++) {
+		if (d->followers[i].id == id && spa_streq(d->followers[i].name, name))
+			return i;
+	}
+	return -1;
+}
+
+static int add_follower(struct data *d, uint32_t id, const char *name)
+{
+	int idx = d->n_followers;
+
+	if (idx == MAX_FOLLOWERS)
+		return -1;
+
+	d->n_followers++;
+
+	strncpy(d->followers[idx].name, name, MAX_NAME);
+	d->followers[idx].name[MAX_NAME-1] = '\0';
+	d->followers[idx].id = id;
+	printf("logging follower %u (\"%s\")\n", id, name);
+
+	return idx;
+}
+
+static int process_follower_block(struct data *d, const struct spa_pod *pod, struct point *point)
+{
+	uint32_t id = 0;
+	const char *name =  NULL;
+	struct measurement m;
+	int res, idx;
+
+	spa_zero(m);
+	if ((res = spa_pod_parse_struct(pod,
+			SPA_POD_Int(&id),
+			SPA_POD_String(&name),
+			SPA_POD_Long(&m.prev_signal),
+			SPA_POD_Long(&m.signal),
+			SPA_POD_Long(&m.awake),
+			SPA_POD_Long(&m.finish),
+			SPA_POD_Int(&m.status))) < 0)
+		return res;
+
+	if ((idx = find_follower(d, id, name)) < 0) {
+		if ((idx = add_follower(d, id, name)) < 0) {
+			pw_log_warn("too many followers");
+			return -ENOSPC;
+		}
+	}
+	point->follower[idx] = m;
+	return 0;
+}
+
+static void dump_point(struct data *d, struct point *point)
+{
+	int i;
+	int64_t d1, d2;
+	int64_t delay, period_usecs;
+
+#define CLOCK_AS_USEC(cl,val) (val * (float)SPA_USEC_PER_SEC / (cl)->rate.denom)
+#define CLOCK_AS_SUSEC(cl,val) (val * (float)SPA_USEC_PER_SEC / ((cl)->rate.denom * (cl)->rate_diff))
+
+	delay = CLOCK_AS_USEC(&point->clock, point->clock.delay);
+	period_usecs = CLOCK_AS_SUSEC(&point->clock, point->clock.duration);
+
+	d1 = (point->driver.signal - point->driver.prev_signal) / 1000;
+	d2 = (point->driver.finish - point->driver.signal) / 1000;
+
+	if (d1 > period_usecs * 1.3 ||
+	    d2 > period_usecs * 1.3)
+		d1 = d2 = period_usecs * 1.4;
+
+	/* 4 columns for the driver */
+	fprintf(d->output, "%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t",
+			d1 > 0 ? d1 : 0, d2 > 0 ? d2 : 0, delay, period_usecs);
+
+	for (i = 0; i < MAX_FOLLOWERS; i++) {
+		/* 8 columns for each follower */
+		if (point->follower[i].status == 0) {
+			fprintf(d->output, " \t \t \t \t \t \t \t \t");
+		} else {
+			int64_t d4 = (point->follower[i].signal - point->driver.signal) / 1000;
+			int64_t d5 = (point->follower[i].awake - point->driver.signal) / 1000;
+			int64_t d6 = (point->follower[i].finish - point->driver.signal) / 1000;
+
+			fprintf(d->output, "%u\t%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t%"PRIi64"\t%d\t0\t",
+					d->followers[i].id,
+					d4 > 0 ? d4 : 0,
+					d5 > 0 ? d5 : 0,
+					d6 > 0 ? d6 : 0,
+					(d5 > 0 && d4 > 0 && d5 > d4) ? d5 - d4 : 0,
+					(d6 > 0 && d5 > 0 && d6 > d5) ? d6 - d5 : 0,
+					point->follower[i].status);
+		}
+	}
+	fprintf(d->output, "\n");
+	if (d->count == 0) {
+		d->start_status = point->clock.nsec;
+		d->last_status = point->clock.nsec;
+	}
+	else if (point->clock.nsec - d->last_status > SPA_NSEC_PER_SEC) {
+		printf("logging %"PRIi64" samples  %"PRIi64" seconds [CPU %f %f %f]\r",
+				d->count, (int64_t) ((d->last_status - d->start_status) / SPA_NSEC_PER_SEC),
+				point->cpu_load[0], point->cpu_load[1], point->cpu_load[2]);
+		d->last_status = point->clock.nsec;
+	}
+	d->count++;
+}
+
+static void dump_scripts(struct data *d)
+{
+	FILE *out;
+	int i;
+
+	if (d->driver_id == 0)
+		return;
+
+	printf("\ndumping scripts for %d followers\n", d->n_followers);
+
+	out = fopen("Timing1.plot", "we");
+	if (out == NULL) {
+		pw_log_error("Can't open Timing1.plot: %m");
+	} else {
+		fprintf(out,
+			"set output 'Timing1.svg\n"
+			"set terminal svg\n"
+			"set multiplot\n"
+			"set grid\n"
+			"set title \"Audio driver timing\"\n"
+			"set xlabel \"audio cycles\"\n"
+			"set ylabel \"usec\"\n"
+			"plot \"%1$s\" using 3 title \"Audio driver delay\" with lines, "
+			"\"%1$s\" using 1 title \"Audio period\" with lines,"
+			"\"%1$s\" using 4 title \"Audio estimated\" with lines\n"
+			"unset multiplot\n"
+			"unset output\n", d->filename);
+		fclose(out);
+	}
+
+	out = fopen("Timing2.plot", "we");
+	if (out == NULL) {
+		pw_log_error("Can't open Timing2.plot: %m");
+	} else {
+		fprintf(out,
+			"set output 'Timing2.svg\n"
+			"set terminal svg\n"
+			"set grid\n"
+			"set title \"Driver end date\"\n"
+			"set xlabel \"audio cycles\"\n"
+			"set ylabel \"usec\"\n"
+			"plot  \"%s\" using 2 title \"Driver end date\" with lines \n"
+			"unset output\n", d->filename);
+		fclose(out);
+	}
+
+	out = fopen("Timing3.plot", "we");
+	if (out == NULL) {
+		pw_log_error("Can't open Timing3.plot: %m");
+	} else {
+		fprintf(out,
+			"set output 'Timing3.svg\n"
+			"set terminal svg\n"
+			"set multiplot\n"
+			"set grid\n"
+			"set title \"Clients end date\"\n"
+			"set xlabel \"audio cycles\"\n"
+			"set ylabel \"usec\"\n"
+			"plot "
+			"\"%s\" using 1 title \"Audio period\" with lines%s",
+				d->filename,
+				d->n_followers > 0 ? ", " : "");
+
+		for (i = 0; i < d->n_followers; i++) {
+			fprintf(out,
+				"\"%s\" using %d title \"%s/%u\" with lines%s",
+					d->filename, 4 + (i * 8) + 4,
+					d->followers[i].name, d->followers[i].id,
+					i+1 < d->n_followers ? ", " : "");
+		}
+		fprintf(out,
+			"\nunset multiplot\n"
+			"unset output\n");
+		fclose(out);
+	}
+
+	out = fopen("Timing4.plot", "we");
+	if (out == NULL) {
+		pw_log_error("Can't open Timing4.plot: %m");
+	} else {
+		fprintf(out,
+			"set output 'Timing4.svg\n"
+			"set terminal svg\n"
+			"set multiplot\n"
+			"set grid\n"
+			"set title \"Clients scheduling latency\"\n"
+			"set xlabel \"audio cycles\"\n"
+			"set ylabel \"usec\"\n"
+			"plot ");
+
+		for (i = 0; i < d->n_followers; i++) {
+			fprintf(out,
+				"\"%s\" using %d title \"%s/%u\" with lines%s",
+					d->filename, 4 + (i * 8) + 5,
+					d->followers[i].name, d->followers[i].id,
+					i+1 < d->n_followers ? ", " : "");
+		}
+		fprintf(out,
+			"\nunset multiplot\n"
+			"unset output\n");
+		fclose(out);
+	}
+
+	out = fopen("Timing5.plot", "we");
+	if (out == NULL) {
+		pw_log_error("Can't open Timing5.plot: %m");
+	} else {
+		fprintf(out,
+			"set output 'Timing5.svg\n"
+			"set terminal svg\n"
+			"set multiplot\n"
+			"set grid\n"
+			"set title \"Clients duration\"\n"
+			"set xlabel \"audio cycles\"\n"
+			"set ylabel \"usec\"\n"
+			"plot ");
+
+		for (i = 0; i < d->n_followers; i++) {
+			fprintf(out,
+				"\"%s\" using %d title \"%s/%u\" with lines%s",
+					d->filename, 4 + (i * 8) + 6,
+					d->followers[i].name, d->followers[i].id,
+					i+1 < d->n_followers ? ", " : "");
+		}
+		fprintf(out,
+			"\nunset multiplot\n"
+			"unset output\n");
+		fclose(out);
+	}
+	out = fopen("Timings.html", "we");
+	if (out == NULL) {
+		pw_log_error("Can't open Timings.html: %m");
+	} else {
+		fprintf(out,
+			"<?xml version='1.0' encoding='utf-8'?>\n"
+			"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
+			"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"
+			"<html xmlns='http://www.w3.org/1999/xhtml' lang='en'>\n"
+			"  <head>\n"
+			"    <title>PipeWire profiling</title>\n"
+			"    <!-- assuming that images are 600px wide -->\n"
+			"    <style media='all' type='text/css'>\n"
+			"    .center { margin-left:auto ; margin-right: auto; width: 650px; height: 550px }\n"
+			"    </style>\n"
+			"  </head>\n"
+			"  <body>\n"
+			"    <h2 style='text-align:center'>PipeWire profiling</h2>\n"
+			"    <div class='center'><object class='center' type='image/svg+xml' data='Timing1.svg'>Timing1</object></div>"
+			"    <div class='center'><object class='center' type='image/svg+xml' data='Timing2.svg'>Timing2</object></div>"
+			"    <div class='center'><object class='center' type='image/svg+xml' data='Timing3.svg'>Timing3</object></div>"
+			"    <div class='center'><object class='center' type='image/svg+xml' data='Timing4.svg'>Timing4</object></div>"
+			"    <div class='center'><object class='center' type='image/svg+xml' data='Timing5.svg'>Timing5</object></div>"
+			"  </body>\n"
+			"</html>\n");
+		fclose(out);
+	}
+
+	out = fopen("generate_timings.sh", "we");
+	if (out == NULL) {
+		pw_log_error("Can't open generate_timings.sh: %m");
+	} else {
+		fprintf(out,
+			"gnuplot Timing1.plot\n"
+			"gnuplot Timing2.plot\n"
+			"gnuplot Timing3.plot\n"
+			"gnuplot Timing4.plot\n"
+			"gnuplot Timing5.plot\n");
+		fclose(out);
+	}
+	printf("run 'sh generate_timings.sh' and load Timings.html in a browser\n");
+}
+
+static void profiler_profile(void *data, const struct spa_pod *pod)
+{
+        struct data *d = data;
+	struct spa_pod *o;
+	struct spa_pod_prop *p;
+	struct point point;
+
+	SPA_POD_STRUCT_FOREACH(pod, o) {
+		int res = 0;
+		if (!spa_pod_is_object_type(o, SPA_TYPE_OBJECT_Profiler))
+			continue;
+
+		spa_zero(point);
+		SPA_POD_OBJECT_FOREACH((struct spa_pod_object*)o, p) {
+			switch(p->key) {
+			case SPA_PROFILER_info:
+				res = process_info(d, &p->value, &point);
+				break;
+			case SPA_PROFILER_clock:
+				res = process_clock(d, &p->value, &point);
+				break;
+			case SPA_PROFILER_driverBlock:
+				res = process_driver_block(d, &p->value, &point);
+				break;
+			case SPA_PROFILER_followerBlock:
+				process_follower_block(d, &p->value, &point);
+				break;
+			default:
+				break;
+			}
+			if (res < 0)
+				break;
+		}
+		if (res < 0)
+			continue;
+
+		dump_point(d, &point);
+	}
+}
+
+static const struct pw_profiler_events profiler_events = {
+	PW_VERSION_PROFILER_EVENTS,
+        .profile = profiler_profile,
+};
+
+static void registry_event_global(void *data, uint32_t id,
+				  uint32_t permissions, const char *type, uint32_t version,
+				  const struct spa_dict *props)
+{
+	struct data *d = data;
+	struct pw_proxy *proxy;
+
+	if (!spa_streq(type, PW_TYPE_INTERFACE_Profiler))
+		return;
+
+	if (d->profiler != NULL) {
+		fprintf(stderr, "Ignoring profiler %d: already attached\n", id);
+		return;
+	}
+
+	proxy = pw_registry_bind(d->registry, id, type, PW_VERSION_PROFILER, 0);
+	if (proxy == NULL)
+		goto error_proxy;
+
+	printf("Attaching to Profiler id:%d\n", id);
+	d->profiler = proxy;
+	pw_proxy_add_object_listener(proxy, &d->profiler_listener, &profiler_events, d);
+
+	return;
+
+error_proxy:
+	pw_log_error("failed to create proxy: %m");
+	return;
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+};
+
+static void on_core_error(void *_data, uint32_t id, int seq, int res, const char *message)
+{
+	struct data *data = _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_main_loop_quit(data->loop);
+}
+
+static void on_core_done(void *_data, uint32_t id, int seq)
+{
+	struct data *d = _data;
+
+	if (seq == d->check_profiler) {
+		if (d->profiler == NULL) {
+			pw_log_error("no Profiler Interface found, please load one in the server");
+			pw_main_loop_quit(d->loop);
+		}
+	}
+}
+
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.error = on_core_error,
+	.done = on_core_done,
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static void show_help(const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote                          Remote daemon name\n"
+		"  -o, --output                          Profiler output name (default \"%s\")\n",
+		name,
+		DEFAULT_FILENAME);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct pw_loop *l;
+	const char *opt_remote = NULL;
+	const char *opt_output = DEFAULT_FILENAME;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ "output",	required_argument,	NULL, 'o' },
+		{ NULL, 0, NULL, 0}
+	};
+	int c;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	while ((c = getopt_long(argc, argv, "hVr:o:", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h':
+			show_help(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 'o':
+			opt_output = optarg;
+			break;
+		case 'r':
+			opt_remote = optarg;
+			break;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "Can't create data loop: %m\n");
+		return -1;
+	}
+
+	l = pw_main_loop_get_loop(data.loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data.context = pw_context_new(l, NULL, 0);
+	if (data.context == NULL) {
+		fprintf(stderr, "Can't create context: %m\n");
+		return -1;
+	}
+
+	pw_context_load_module(data.context, PW_EXTENSION_MODULE_PROFILER, NULL, NULL);
+
+	data.core = pw_context_connect(data.context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, opt_remote,
+				NULL),
+			0);
+	if (data.core == NULL) {
+		fprintf(stderr, "Can't connect: %m\n");
+		return -1;
+	}
+
+	data.filename = opt_output;
+
+	data.output = fopen(data.filename, "we");
+	if (data.output == NULL) {
+		fprintf(stderr, "Can't open file %s: %m\n", data.filename);
+		return -1;
+	}
+
+	printf("Logging to %s\n", data.filename);
+
+	pw_core_add_listener(data.core,
+				   &data.core_listener,
+				   &core_events, &data);
+	data.registry = pw_core_get_registry(data.core,
+					  PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data.registry,
+				       &data.registry_listener,
+				       &registry_events, &data);
+
+	data.check_profiler = pw_core_sync(data.core, 0, 0);
+
+	pw_main_loop_run(data.loop);
+
+	if (data.profiler) {
+		spa_hook_remove(&data.profiler_listener);
+		pw_proxy_destroy((struct pw_proxy*)data.profiler);
+	}
+	spa_hook_remove(&data.registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data.registry);
+	spa_hook_remove(&data.core_listener);
+	pw_context_destroy(data.context);
+	pw_main_loop_destroy(data.loop);
+
+	fclose(data.output);
+
+	dump_scripts(&data);
+
+	pw_deinit();
+
+	return 0;
+}
diff --git a/src/tools/pw-reserve.c b/src/tools/pw-reserve.c
new file mode 100644
index 0000000..45a3c45
--- /dev/null
+++ b/src/tools/pw-reserve.c
@@ -0,0 +1,253 @@
+/* PipeWire
+ *
+ * Copyright © 2020 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 "config.h"
+
+#include <getopt.h>
+#include <signal.h>
+#include <locale.h>
+
+#include <dbus/dbus.h>
+
+#include <spa/utils/result.h>
+#include <spa/support/dbus.h>
+
+#include "pipewire/pipewire.h"
+#include "pipewire/log.h"
+
+#include "reserve.h"
+
+struct impl {
+	struct pw_main_loop *mainloop;
+	struct pw_loop *loop;
+	struct pw_context *context;
+
+	struct spa_dbus *dbus;
+	struct spa_dbus_connection *dbus_connection;
+	DBusConnection *conn;
+
+	struct rd_device *device;
+};
+
+static void reserve_acquired(void *data, struct rd_device *d)
+{
+	printf("reserve acquired\n");
+}
+
+static void reserve_release(void *data, struct rd_device *d, int forced)
+{
+	struct impl *impl = data;
+	printf("reserve release\n");
+	rd_device_complete_release(impl->device, true);
+}
+
+static void reserve_busy(void *data, struct rd_device *d, const char *name, int32_t prio)
+{
+	printf("reserve busy %s, prio %d\n", name, prio);
+}
+
+static void reserve_available(void *data, struct rd_device *d, const char *name)
+{
+	printf("reserve available %s\n", name);
+}
+
+static const struct rd_device_callbacks reserve_callbacks = {
+	.acquired = reserve_acquired,
+	.release = reserve_release,
+	.busy = reserve_busy,
+	.available = reserve_available,
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct impl *impl = data;
+	pw_main_loop_quit(impl->mainloop);
+}
+
+#define DEFAULT_APPNAME		"pw-reserve"
+#define DEFAULT_PRIORITY	0
+
+static void show_help(const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options]\n"
+             "  -h, --help                            Show this help\n"
+             "      --version                         Show version\n"
+             "  -n, --name                            Name to reserve (Audio0, Midi0, Video0, ..)\n"
+             "  -a, --appname                         Application Name (default %s)\n"
+             "  -p, --priority                        Priority (default %d)\n"
+             "  -m, --monitor                         Monitor only, don't try to acquire\n"
+             "  -r, --release                         Request release when busy\n",
+	     name, DEFAULT_APPNAME, DEFAULT_PRIORITY);
+}
+
+int main(int argc, char *argv[])
+{
+	struct impl impl = { 0, };
+	const struct spa_support *support;
+	uint32_t n_support;
+	const char *opt_name = NULL;
+	const char *opt_appname = DEFAULT_APPNAME;
+	bool opt_monitor = false;
+	bool opt_release = false;
+	int opt_priority= DEFAULT_PRIORITY;
+
+	int res = 0, c;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "name",	required_argument,	NULL, 'n' },
+		{ "app",	required_argument,	NULL, 'a' },
+		{ "priority",	required_argument,	NULL, 'p' },
+		{ "monitor",	no_argument,		NULL, 'm' },
+		{ "release",	no_argument,		NULL, 'r' },
+		{ NULL, 0, NULL, 0}
+	};
+
+	setlinebuf(stdout);
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	while ((c = getopt_long(argc, argv, "hVn:a:p:mr", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h':
+			show_help(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 'n':
+			opt_name = optarg;
+			break;
+		case 'a':
+			opt_appname = optarg;
+			break;
+		case 'p':
+			opt_priority = atoi(optarg);
+			break;
+		case 'm':
+			opt_monitor = true;
+			break;
+		case 'r':
+			opt_release = true;
+			break;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+	if (opt_name == NULL) {
+		fprintf(stderr, "name must be given\n");
+		return -1;
+	}
+
+	impl.mainloop = pw_main_loop_new(NULL);
+	if (impl.mainloop == NULL) {
+		fprintf(stderr, "can't create mainloop: %m\n");
+		res = -errno;
+		goto exit;
+	}
+	impl.loop = pw_main_loop_get_loop(impl.mainloop);
+
+	pw_loop_add_signal(impl.loop, SIGINT, do_quit, &impl);
+	pw_loop_add_signal(impl.loop, SIGTERM, do_quit, &impl);
+
+	impl.context = pw_context_new(impl.loop, NULL, 0);
+	if (impl.context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		res = -errno;
+		goto exit;
+	}
+
+	support = pw_context_get_support(impl.context, &n_support);
+
+	impl.dbus = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_DBus);
+	if (impl.dbus)
+		impl.dbus_connection = spa_dbus_get_connection(impl.dbus, SPA_DBUS_TYPE_SESSION);
+	if (impl.dbus_connection == NULL) {
+		fprintf(stderr, "no dbus connection: %m\n");
+		res = -errno;
+		goto exit;
+	}
+	impl.conn = spa_dbus_connection_get(impl.dbus_connection);
+	if (impl.conn == NULL) {
+		fprintf(stderr, "no dbus connection: %m\n");
+		res = -errno;
+		goto exit;
+	}
+
+	/* XXX: we don't handle dbus reconnection yet, so ref the handle instead */
+	dbus_connection_ref(impl.conn);
+
+	impl.device = rd_device_new(impl.conn,
+			opt_name,
+			opt_appname,
+			opt_priority,
+			&reserve_callbacks, &impl);
+
+	if (!opt_monitor) {
+		res = rd_device_acquire(impl.device);
+		if (res == -EBUSY) {
+			printf("device %s is busy\n", opt_name);
+			if (opt_release) {
+				printf("doing RequestRelease on %s\n", opt_name);
+				res = rd_device_request_release(impl.device);
+			} else {
+				printf("use -r to attempt to release\n");
+			}
+		} else if (res < 0) {
+			printf("Device %s can not be acquired: %s\n", opt_name,
+					spa_strerror(res));
+		}
+	}
+
+	if (res >= 0)
+		pw_main_loop_run(impl.mainloop);
+
+	if (!opt_monitor) {
+		if (opt_release) {
+			printf("doing Release on %s\n", opt_name);
+			rd_device_release(impl.device);
+		}
+	}
+
+exit:
+	if (impl.conn)
+		dbus_connection_unref(impl.conn);
+	if (impl.dbus)
+		spa_dbus_connection_destroy(impl.dbus_connection);
+	if (impl.context)
+		pw_context_destroy(impl.context);
+	if (impl.mainloop)
+		pw_main_loop_destroy(impl.mainloop);
+
+	pw_deinit();
+
+	return res;
+}
diff --git a/src/tools/pw-top.c b/src/tools/pw-top.c
new file mode 100644
index 0000000..a20bdf9
--- /dev/null
+++ b/src/tools/pw-top.c
@@ -0,0 +1,862 @@
+/* PipeWire
+ *
+ * Copyright © 2020 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 <stdio.h>
+#include <signal.h>
+#include <getopt.h>
+#include <locale.h>
+#include <ncurses.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/pod/parser.h>
+#include <spa/debug/types.h>
+#include <spa/param/format-utils.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/video/format-utils.h>
+
+#include <pipewire/impl.h>
+#include <pipewire/extensions/profiler.h>
+
+#define MAX_FORMAT		16
+#define MAX_NAME		128
+
+struct driver {
+	int64_t count;
+	float cpu_load[3];
+	struct spa_io_clock clock;
+	uint32_t xrun_count;
+};
+
+struct measurement {
+	int32_t index;
+	int32_t status;
+	int64_t quantum;
+	int64_t prev_signal;
+	int64_t signal;
+	int64_t awake;
+	int64_t finish;
+	struct spa_fraction latency;
+};
+
+struct node {
+	struct spa_list link;
+	struct data *data;
+	uint32_t id;
+	char name[MAX_NAME+1];
+	enum pw_node_state state;
+	struct measurement measurement;
+	struct driver info;
+	struct node *driver;
+	uint32_t errors;
+	int32_t last_error_status;
+	uint32_t generation;
+	char format[MAX_FORMAT+1];
+	struct pw_proxy *proxy;
+	struct spa_hook proxy_listener;
+	unsigned int inactive:1;
+	struct spa_hook object_listener;
+};
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct pw_proxy *profiler;
+	struct spa_hook profiler_listener;
+	int check_profiler;
+
+	struct spa_source *timer;
+
+	int n_nodes;
+	struct spa_list node_list;
+	uint32_t generation;
+	unsigned pending_refresh:1;
+
+	WINDOW *win;
+};
+
+struct point {
+	struct node *driver;
+	struct driver info;
+};
+
+static int process_info(struct data *d, const struct spa_pod *pod, struct driver *info)
+{
+	return spa_pod_parse_struct(pod,
+			SPA_POD_Long(&info->count),
+			SPA_POD_Float(&info->cpu_load[0]),
+			SPA_POD_Float(&info->cpu_load[1]),
+			SPA_POD_Float(&info->cpu_load[2]),
+			SPA_POD_Int(&info->xrun_count));
+}
+
+static int process_clock(struct data *d, const struct spa_pod *pod, struct driver *info)
+{
+	return spa_pod_parse_struct(pod,
+			SPA_POD_Int(&info->clock.flags),
+			SPA_POD_Int(&info->clock.id),
+			SPA_POD_Stringn(info->clock.name, sizeof(info->clock.name)),
+			SPA_POD_Long(&info->clock.nsec),
+			SPA_POD_Fraction(&info->clock.rate),
+			SPA_POD_Long(&info->clock.position),
+			SPA_POD_Long(&info->clock.duration),
+			SPA_POD_Long(&info->clock.delay),
+			SPA_POD_Double(&info->clock.rate_diff),
+			SPA_POD_Long(&info->clock.next_nsec));
+}
+
+static struct node *find_node(struct data *d, uint32_t id)
+{
+	struct node *n;
+	spa_list_for_each(n, &d->node_list, link) {
+		if (n->id == id)
+			return n;
+	}
+	return NULL;
+}
+
+static void on_node_removed(void *data)
+{
+	struct node *n = data;
+	pw_proxy_destroy(n->proxy);
+}
+
+static void on_node_destroy(void *data)
+{
+	struct node *n = data;
+	n->proxy = NULL;
+	spa_hook_remove(&n->proxy_listener);
+	spa_hook_remove(&n->object_listener);
+}
+
+static const struct pw_proxy_events proxy_events = {
+	PW_VERSION_PROXY_EVENTS,
+	.removed = on_node_removed,
+	.destroy = on_node_destroy,
+};
+
+static void do_refresh(struct data *d);
+
+static void node_info(void *data, const struct pw_node_info *info)
+{
+	struct node *n = data;
+
+	if (n->state != info->state) {
+		n->state = info->state;
+		do_refresh(n->data);
+	}
+}
+
+static void node_param(void *data, int seq,
+			uint32_t id, uint32_t index, uint32_t next,
+			const struct spa_pod *param)
+{
+	struct node *n = data;
+
+	if (param == NULL) {
+		spa_zero(n->format);
+		goto done;
+	}
+
+	switch (id) {
+	case SPA_PARAM_Format:
+	{
+		uint32_t media_type, media_subtype;
+
+		spa_format_parse(param, &media_type, &media_subtype);
+
+		switch(media_type) {
+		case SPA_MEDIA_TYPE_audio:
+			switch(media_subtype) {
+			case SPA_MEDIA_SUBTYPE_raw:
+			{
+				struct spa_audio_info_raw info = { 0 };
+				if (spa_format_audio_raw_parse(param, &info) >= 0) {
+					snprintf(n->format, sizeof(n->format), "%6.6s %d %d",
+						spa_debug_type_find_short_name(
+							spa_type_audio_format, info.format),
+						info.channels, info.rate);
+				}
+				break;
+			}
+			case SPA_MEDIA_SUBTYPE_dsd:
+			{
+				struct spa_audio_info_dsd info = { 0 };
+				if (spa_format_audio_dsd_parse(param, &info) >= 0) {
+					snprintf(n->format, sizeof(n->format), "DSD%d %d ",
+						8 * info.rate / 44100, info.channels);
+
+				}
+				break;
+			}
+			case SPA_MEDIA_SUBTYPE_iec958:
+			{
+				struct spa_audio_info_iec958 info = { 0 };
+				if (spa_format_audio_iec958_parse(param, &info) >= 0) {
+					snprintf(n->format, sizeof(n->format), "IEC958 %s %d",
+						spa_debug_type_find_short_name(
+							spa_type_audio_iec958_codec, info.codec),
+						info.rate);
+
+				}
+				break;
+			}
+			}
+			break;
+		case SPA_MEDIA_TYPE_video:
+			switch(media_subtype) {
+			case SPA_MEDIA_SUBTYPE_raw:
+			{
+				struct spa_video_info_raw info = { 0 };
+				if (spa_format_video_raw_parse(param, &info) >= 0) {
+					snprintf(n->format, sizeof(n->format), "%6.6s %dx%d",
+						spa_debug_type_find_short_name(spa_type_video_format, info.format),
+						info.size.width, info.size.height);
+				}
+				break;
+			}
+			case SPA_MEDIA_SUBTYPE_mjpg:
+			{
+				struct spa_video_info_mjpg info = { 0 };
+				if (spa_format_video_mjpg_parse(param, &info) >= 0) {
+					snprintf(n->format, sizeof(n->format), "MJPG %dx%d",
+						info.size.width, info.size.height);
+				}
+				break;
+			}
+			case SPA_MEDIA_SUBTYPE_h264:
+			{
+				struct spa_video_info_h264 info = { 0 };
+				if (spa_format_video_h264_parse(param, &info) >= 0) {
+					snprintf(n->format, sizeof(n->format), "H264 %dx%d",
+						info.size.width, info.size.height);
+				}
+				break;
+			}
+			}
+			break;
+		case SPA_MEDIA_TYPE_application:
+			switch(media_subtype) {
+			case SPA_MEDIA_SUBTYPE_control:
+				snprintf(n->format, sizeof(n->format), "%s", "CONTROL");
+				break;
+			}
+			break;
+		}
+		break;
+	}
+	default:
+		break;
+	}
+done:
+	do_refresh(n->data);
+}
+
+static const struct pw_node_events node_events = {
+	PW_VERSION_NODE,
+	.info = node_info,
+	.param = node_param,
+};
+
+static struct node *add_node(struct data *d, uint32_t id, const char *name)
+{
+	struct node *n;
+
+	if ((n = calloc(1, sizeof(*n))) == NULL)
+		return NULL;
+
+	if (name)
+		strncpy(n->name, name, MAX_NAME);
+	else
+		snprintf(n->name, sizeof(n->name), "%u", id);
+	n->data = d;
+	n->id = id;
+	n->driver = n;
+	n->proxy = pw_registry_bind(d->registry, id, PW_TYPE_INTERFACE_Node, PW_VERSION_NODE, 0);
+	if (n->proxy) {
+		uint32_t ids[1] = { SPA_PARAM_Format };
+
+		pw_proxy_add_listener(n->proxy,
+				&n->proxy_listener, &proxy_events, n);
+		pw_proxy_add_object_listener(n->proxy,
+				&n->object_listener, &node_events, n);
+
+		pw_node_subscribe_params((struct pw_node*)n->proxy,
+						ids, 1);
+	}
+	spa_list_append(&d->node_list, &n->link);
+	d->n_nodes++;
+	d->pending_refresh = true;
+
+	return n;
+}
+
+static void remove_node(struct data *d, struct node *n)
+{
+	if (n->proxy)
+		pw_proxy_destroy(n->proxy);
+	spa_list_remove(&n->link);
+	d->n_nodes--;
+	d->pending_refresh = true;
+	free(n);
+}
+
+static int process_driver_block(struct data *d, const struct spa_pod *pod, struct point *point)
+{
+	char *name = NULL;
+	uint32_t id = 0;
+	struct measurement m;
+	struct node *n;
+	int res;
+
+	spa_zero(m);
+	if ((res = spa_pod_parse_struct(pod,
+			SPA_POD_Int(&id),
+			SPA_POD_String(&name),
+			SPA_POD_Long(&m.prev_signal),
+			SPA_POD_Long(&m.signal),
+			SPA_POD_Long(&m.awake),
+			SPA_POD_Long(&m.finish),
+			SPA_POD_Int(&m.status),
+			SPA_POD_Fraction(&m.latency))) < 0)
+		return res;
+
+	if ((n = find_node(d, id)) == NULL)
+		return -ENOENT;
+
+	n->driver = n;
+	n->measurement = m;
+	n->info = point->info;
+	point->driver = n;
+	n->generation = d->generation;
+
+	if (m.status != 3) {
+		n->errors++;
+		if (n->last_error_status == -1)
+			n->last_error_status = m.status;
+	}
+	return 0;
+}
+
+static int process_follower_block(struct data *d, const struct spa_pod *pod, struct point *point)
+{
+	uint32_t id = 0;
+	const char *name =  NULL;
+	struct measurement m;
+	struct node *n;
+	int res;
+
+	spa_zero(m);
+	if ((res = spa_pod_parse_struct(pod,
+			SPA_POD_Int(&id),
+			SPA_POD_String(&name),
+			SPA_POD_Long(&m.prev_signal),
+			SPA_POD_Long(&m.signal),
+			SPA_POD_Long(&m.awake),
+			SPA_POD_Long(&m.finish),
+			SPA_POD_Int(&m.status),
+			SPA_POD_Fraction(&m.latency))) < 0)
+		return res;
+
+	if ((n = find_node(d, id)) == NULL)
+		return -ENOENT;
+
+	n->measurement = m;
+	if (n->driver != point->driver) {
+		n->driver = point->driver;
+		d->pending_refresh = true;
+	}
+	n->generation = d->generation;
+	if (m.status != 3) {
+		n->errors++;
+		if (n->last_error_status == -1)
+			n->last_error_status = m.status;
+	}
+	return 0;
+}
+
+static const char *print_time(char *buf, bool active, size_t len, uint64_t val)
+{
+	if (val == (uint64_t)-1 || !active)
+		snprintf(buf, len, "   --- ");
+	else if (val == (uint64_t)-2)
+		snprintf(buf, len, "   +++ ");
+	else if (val < 1000000llu)
+		snprintf(buf, len, "%5.1fus", val/1000.f);
+	else if (val < 1000000000llu)
+		snprintf(buf, len, "%5.1fms", val/1000000.f);
+	else
+		snprintf(buf, len, "%5.1fs", val/1000000000.f);
+	return buf;
+}
+
+static const char *print_perc(char *buf, bool active, size_t len, uint64_t val, float quantum)
+{
+	if (val == (uint64_t)-1 || !active) {
+		snprintf(buf, len, " --- ");
+	} else if (val == (uint64_t)-2) {
+		snprintf(buf, len, " +++ ");
+	} else {
+		float frac = val / 1000000000.f;
+		snprintf(buf, len, "%5.2f", quantum == 0.0f ? 0.0f : frac/quantum);
+	}
+	return buf;
+}
+
+static const char *state_as_string(enum pw_node_state state)
+{
+	switch (state) {
+	case PW_NODE_STATE_ERROR:
+		return "E";
+	case PW_NODE_STATE_CREATING:
+		return "C";
+	case PW_NODE_STATE_SUSPENDED:
+		return "S";
+	case PW_NODE_STATE_IDLE:
+		return "I";
+	case PW_NODE_STATE_RUNNING:
+		return "R";
+	}
+	return "!";
+}
+
+static void print_node(struct data *d, struct driver *i, struct node *n, int y)
+{
+	char buf1[64];
+	char buf2[64];
+	char buf3[64];
+	char buf4[64];
+	uint64_t waiting, busy;
+	float quantum;
+	struct spa_fraction frac;
+	bool active;
+
+	active = n->state == PW_NODE_STATE_RUNNING || n->state == PW_NODE_STATE_IDLE;
+
+	if (!active)
+		frac = SPA_FRACTION(0, 0);
+	else if (n->driver == n)
+		frac = SPA_FRACTION((uint32_t)(i->clock.duration * i->clock.rate.num), i->clock.rate.denom);
+	else
+		frac = SPA_FRACTION(n->measurement.latency.num, n->measurement.latency.denom);
+
+	if (i->clock.rate.denom)
+		quantum = (float)i->clock.duration * i->clock.rate.num / (float)i->clock.rate.denom;
+	else
+		quantum = 0.0;
+
+	if (n->measurement.awake >= n->measurement.signal)
+		waiting = n->measurement.awake - n->measurement.signal;
+	else if (n->measurement.signal > n->measurement.prev_signal)
+		waiting = -2;
+	else
+		waiting = -1;
+
+	if (n->measurement.finish >= n->measurement.awake)
+		busy = n->measurement.finish - n->measurement.awake;
+	else if (n->measurement.awake > n->measurement.prev_signal)
+		busy = -2;
+	else
+		busy = -1;
+
+	mvwprintw(d->win, y, 0, "%s %4.1u %6.1u %6.1u %s %s %s %s  %3.1u %16.16s %s%s",
+			state_as_string(n->state),
+			n->id,
+			frac.num, frac.denom,
+			print_time(buf1, active, 64, waiting),
+			print_time(buf2, active, 64, busy),
+			print_perc(buf3, active, 64, waiting, quantum),
+			print_perc(buf4, active, 64, busy, quantum),
+			i->xrun_count + n->errors,
+			active ? n->format : "",
+			n->driver == n ? "" : " + ",
+			n->name);
+}
+
+static void clear_node(struct node *n)
+{
+	n->driver = n;
+	spa_zero(n->measurement);
+	spa_zero(n->info);
+	n->errors = 0;
+	n->last_error_status = 0;
+}
+
+static void do_refresh(struct data *d)
+{
+	struct node *n, *t, *f;
+	int y = 1;
+
+	wclear(d->win);
+	wattron(d->win, A_REVERSE);
+	wprintw(d->win, "%-*.*s", COLS, COLS, "S   ID  QUANT   RATE    WAIT    BUSY   W/Q   B/Q  ERR FORMAT           NAME ");
+	wattroff(d->win, A_REVERSE);
+	wprintw(d->win, "\n");
+
+	spa_list_for_each_safe(n, t, &d->node_list, link) {
+		if (n->driver != n)
+			continue;
+
+		print_node(d, &n->info, n, y++);
+		if(y > LINES)
+			break;
+
+		spa_list_for_each(f, &d->node_list, link) {
+			if (d->generation > f->generation + 22)
+				clear_node(f);
+
+			if (f->driver != n || f == n)
+				continue;
+
+			print_node(d, &n->info, f, y++);
+			if(y > LINES)
+				break;
+
+		}
+	}
+
+	// Clear from last line to the end of the window to hide text wrapping from the last node
+	wmove(d->win, y, 0);
+	wclrtobot(d->win);
+
+	wrefresh(d->win);
+	d->pending_refresh = false;
+}
+
+static void do_timeout(void *data, uint64_t expirations)
+{
+	struct data *d = data;
+	d->generation++;
+	do_refresh(d);
+}
+
+static void profiler_profile(void *data, const struct spa_pod *pod)
+{
+        struct data *d = data;
+	struct spa_pod *o;
+	struct spa_pod_prop *p;
+	struct point point;
+
+	SPA_POD_STRUCT_FOREACH(pod, o) {
+		int res = 0;
+		if (!spa_pod_is_object_type(o, SPA_TYPE_OBJECT_Profiler))
+			continue;
+
+		spa_zero(point);
+		SPA_POD_OBJECT_FOREACH((struct spa_pod_object*)o, p) {
+			switch(p->key) {
+			case SPA_PROFILER_info:
+				res = process_info(d, &p->value, &point.info);
+				break;
+			case SPA_PROFILER_clock:
+				res = process_clock(d, &p->value, &point.info);
+				break;
+			case SPA_PROFILER_driverBlock:
+				res = process_driver_block(d, &p->value, &point);
+				break;
+			case SPA_PROFILER_followerBlock:
+				process_follower_block(d, &p->value, &point);
+				break;
+			default:
+				break;
+			}
+			if (res < 0)
+				break;
+		}
+		if (res < 0)
+			continue;
+	}
+	if (d->pending_refresh)
+		do_refresh(d);
+}
+
+static const struct pw_profiler_events profiler_events = {
+	PW_VERSION_PROFILER_EVENTS,
+        .profile = profiler_profile,
+};
+
+static void registry_event_global(void *data, uint32_t id,
+				  uint32_t permissions, const char *type, uint32_t version,
+				  const struct spa_dict *props)
+{
+	struct data *d = data;
+	struct pw_proxy *proxy;
+
+	if (spa_streq(type, PW_TYPE_INTERFACE_Node)) {
+		const char *str;
+
+		if ((str = spa_dict_lookup(props, PW_KEY_NODE_NAME)) == NULL &&
+			(str = spa_dict_lookup(props, PW_KEY_NODE_DESCRIPTION)) == NULL) {
+				str = spa_dict_lookup(props, PW_KEY_APP_NAME);
+		}
+
+		if (add_node(d, id, str) == NULL) {
+			pw_log_warn("can add node %u: %m", id);
+		}
+	} else if (spa_streq(type, PW_TYPE_INTERFACE_Profiler)) {
+		if (d->profiler != NULL) {
+			printf("Ignoring profiler %d: already attached\n", id);
+			return;
+		}
+
+		proxy = pw_registry_bind(d->registry, id, type, PW_VERSION_PROFILER, 0);
+		if (proxy == NULL)
+			goto error_proxy;
+
+		d->profiler = proxy;
+		pw_proxy_add_object_listener(proxy, &d->profiler_listener, &profiler_events, d);
+	}
+	if (d->pending_refresh)
+		do_refresh(d);
+	return;
+
+error_proxy:
+	pw_log_error("failed to create proxy: %m");
+	return;
+}
+
+static void registry_event_global_remove(void *data, uint32_t id)
+{
+	struct data *d = data;
+	struct node *n;
+	if ((n = find_node(d, id)) != NULL)
+		remove_node(d, n);
+	if (d->pending_refresh)
+		do_refresh(d);
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+	.global_remove = registry_event_global_remove,
+};
+
+static void on_core_error(void *_data, uint32_t id, int seq, int res, const char *message)
+{
+	struct data *data = _data;
+
+	if (id == PW_ID_CORE) {
+		switch (res) {
+		case -EPIPE:
+			pw_main_loop_quit(data->loop);
+			break;
+		default:
+			pw_log_error("error id:%u seq:%d res:%d (%s): %s",
+				id, seq, res, spa_strerror(res), message);
+			break;
+		}
+	} else {
+		pw_log_info("error id:%u seq:%d res:%d (%s): %s",
+				id, seq, res, spa_strerror(res), message);
+	}
+}
+
+static void on_core_done(void *_data, uint32_t id, int seq)
+{
+	struct data *d = _data;
+
+	if (seq == d->check_profiler) {
+		if (d->profiler == NULL) {
+			pw_log_error("no Profiler Interface found, please load one in the server");
+			pw_main_loop_quit(d->loop);
+		} else {
+			do_refresh(d);
+		}
+	}
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.error = on_core_error,
+	.done = on_core_done,
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static void show_help(const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote                          Remote daemon name\n",
+		name);
+}
+
+static void terminal_start(void)
+{
+	initscr();
+	cbreak();
+	noecho();
+	refresh();
+}
+
+static void terminal_stop(void)
+{
+	endwin();
+}
+
+static void do_handle_io(void *data, int fd, uint32_t mask)
+{
+	struct data *d = data;
+
+	if (mask & SPA_IO_IN) {
+		int ch = getch();
+
+		switch(ch) {
+		case 'q':
+			pw_main_loop_quit(d->loop);
+			break;
+		default:
+			do_refresh(d);
+			break;
+		}
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct pw_loop *l;
+	const char *opt_remote = NULL;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ NULL, 0, NULL, 0}
+	};
+	int c;
+	struct timespec value, interval;
+	struct node *n;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	spa_list_init(&data.node_list);
+
+	while ((c = getopt_long(argc, argv, "hVr:o:", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h':
+			show_help(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;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+
+	data.loop = pw_main_loop_new(NULL);
+	if (data.loop == NULL) {
+		fprintf(stderr, "Can't create data loop: %m\n");
+		return -1;
+	}
+
+	l = pw_main_loop_get_loop(data.loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data.context = pw_context_new(l, NULL, 0);
+	if (data.context == NULL) {
+		fprintf(stderr, "Can't create context: %m\n");
+		return -1;
+	}
+
+	pw_context_load_module(data.context, PW_EXTENSION_MODULE_PROFILER, NULL, NULL);
+
+	data.core = pw_context_connect(data.context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, opt_remote,
+				NULL),
+			0);
+	if (data.core == NULL) {
+		fprintf(stderr, "Can't connect: %m\n");
+		return -1;
+	}
+
+	pw_core_add_listener(data.core,
+				   &data.core_listener,
+				   &core_events, &data);
+	data.registry = pw_core_get_registry(data.core,
+					  PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data.registry,
+				       &data.registry_listener,
+				       &registry_events, &data);
+
+	data.check_profiler = pw_core_sync(data.core, 0, 0);
+
+	terminal_start();
+
+	data.win = newwin(LINES, COLS, 0, 0);
+
+	data.timer = pw_loop_add_timer(l, do_timeout, &data);
+	value.tv_sec = 1;
+	value.tv_nsec = 0;
+	interval.tv_sec = 1;
+	interval.tv_nsec = 0;
+	pw_loop_update_timer(l, data.timer, &value, &interval, false);
+
+	pw_loop_add_io(l, fileno(stdin), SPA_IO_IN, false, do_handle_io, &data);
+
+	pw_main_loop_run(data.loop);
+
+	terminal_stop();
+
+	spa_list_consume(n, &data.node_list, link)
+		remove_node(&data, n);
+
+	if (data.profiler) {
+		spa_hook_remove(&data.profiler_listener);
+		pw_proxy_destroy((struct pw_proxy*)data.profiler);
+	}
+	spa_hook_remove(&data.registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data.registry);
+	spa_hook_remove(&data.core_listener);
+	pw_context_destroy(data.context);
+	pw_main_loop_destroy(data.loop);
+
+	pw_deinit();
+
+	return 0;
+}
diff --git a/src/tools/reserve.c b/src/tools/reserve.c
new file mode 100644
index 0000000..2329a14
--- /dev/null
+++ b/src/tools/reserve.c
@@ -0,0 +1,527 @@
+/* DBus device reservation API
+ *
+ * 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.
+ */
+
+#ifndef NAME
+#define NAME "reserve"
+#endif
+
+#include "reserve.h"
+
+#include <spa/utils/string.h>
+#include <pipewire/log.h>
+
+#define SERVICE_PREFIX "org.freedesktop.ReserveDevice1."
+#define OBJECT_PREFIX "/org/freedesktop/ReserveDevice1/"
+
+static const char introspection[] =
+	DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
+	"<node>"
+	" <!-- If you are looking for documentation make sure to check out\n"
+	"      http://git.0pointer.de/?p=reserve.git;a=blob;f=reserve.txt -->\n"
+	" <interface name=\"org.freedesktop.ReserveDevice1\">"
+	"  <method name=\"RequestRelease\">"
+	"   <arg name=\"priority\" type=\"i\" direction=\"in\"/>"
+	"   <arg name=\"result\" type=\"b\" direction=\"out\"/>"
+	"  </method>"
+	"  <property name=\"Priority\" type=\"i\" access=\"read\"/>"
+	"  <property name=\"ApplicationName\" type=\"s\" access=\"read\"/>"
+	"  <property name=\"ApplicationDeviceName\" type=\"s\" access=\"read\"/>"
+	" </interface>"
+	" <interface name=\"org.freedesktop.DBus.Properties\">"
+	"  <method name=\"Get\">"
+	"   <arg name=\"interface\" direction=\"in\" type=\"s\"/>"
+	"   <arg name=\"property\" direction=\"in\" type=\"s\"/>"
+	"   <arg name=\"value\" direction=\"out\" type=\"v\"/>"
+	"  </method>"
+	" </interface>"
+	" <interface name=\"org.freedesktop.DBus.Introspectable\">"
+	"  <method name=\"Introspect\">"
+	"   <arg name=\"data\" type=\"s\" direction=\"out\"/>"
+	"  </method>"
+	" </interface>"
+	"</node>";
+
+struct rd_device {
+	DBusConnection *connection;
+
+	int32_t priority;
+	char *service_name;
+	char *object_path;
+	char *application_name;
+	char *application_device_name;
+
+	const struct rd_device_callbacks *callbacks;
+	void *data;
+
+	DBusMessage *reply;
+
+	unsigned int filtering:1;
+	unsigned int registered:1;
+	unsigned int acquiring:1;
+	unsigned int owning:1;
+};
+
+static dbus_bool_t add_variant(DBusMessage *m, int type, const void *data)
+{
+	DBusMessageIter iter, sub;
+	char t[2];
+
+	t[0] = (char) type;
+	t[1] = 0;
+
+	dbus_message_iter_init_append(m, &iter);
+
+	if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, t, &sub))
+		return false;
+
+	if (!dbus_message_iter_append_basic(&sub, type, data))
+		return false;
+
+	if (!dbus_message_iter_close_container(&iter, &sub))
+		return false;
+
+	return true;
+}
+
+static DBusHandlerResult object_handler(DBusConnection *c, DBusMessage *m, void *userdata)
+{
+	struct rd_device *d = userdata;
+	DBusError error;
+	DBusMessage *reply = NULL;
+
+	dbus_error_init(&error);
+
+	if (dbus_message_is_method_call(m, "org.freedesktop.ReserveDevice1",
+				"RequestRelease")) {
+		int32_t priority;
+
+		if (!dbus_message_get_args(m, &error,
+					DBUS_TYPE_INT32, &priority,
+					DBUS_TYPE_INVALID))
+			goto invalid;
+
+		pw_log_debug("%p: request release priority:%d", d, priority);
+
+		if (!(reply = dbus_message_new_method_return(m)))
+			goto oom;
+
+		if (d->reply)
+			rd_device_complete_release(d, false);
+		d->reply = reply;
+
+		if (priority > d->priority && d->callbacks->release)
+			d->callbacks->release(d->data, d, 0);
+		else
+			rd_device_complete_release(d, false);
+
+		return DBUS_HANDLER_RESULT_HANDLED;
+
+	} else if (dbus_message_is_method_call(
+			   m,
+			   "org.freedesktop.DBus.Properties",
+			   "Get")) {
+
+		const char *interface, *property;
+
+		if (!dbus_message_get_args( m, &error,
+					DBUS_TYPE_STRING, &interface,
+					DBUS_TYPE_STRING, &property,
+					DBUS_TYPE_INVALID))
+			goto invalid;
+
+		if (spa_streq(interface, "org.freedesktop.ReserveDevice1")) {
+			const char *empty = "";
+
+			if (spa_streq(property, "ApplicationName") && d->application_name) {
+				if (!(reply = dbus_message_new_method_return(m)))
+					goto oom;
+
+				if (!add_variant(reply,
+					    DBUS_TYPE_STRING,
+					    d->application_name ? (const char**) &d->application_name : &empty))
+					goto oom;
+
+			} else if (spa_streq(property, "ApplicationDeviceName")) {
+				if (!(reply = dbus_message_new_method_return(m)))
+					goto oom;
+
+				if (!add_variant(reply,
+					    DBUS_TYPE_STRING,
+					    d->application_device_name ? (const char**) &d->application_device_name : &empty))
+					goto oom;
+
+			} else if (spa_streq(property, "Priority")) {
+				if (!(reply = dbus_message_new_method_return(m)))
+					goto oom;
+
+				if (!add_variant(reply,
+					    DBUS_TYPE_INT32, &d->priority))
+					goto oom;
+			} else {
+				if (!(reply = dbus_message_new_error_printf(m,
+								DBUS_ERROR_UNKNOWN_METHOD,
+								"Unknown property %s", property)))
+					goto oom;
+			}
+
+			if (!dbus_connection_send(c, reply, NULL))
+				goto oom;
+
+			dbus_message_unref(reply);
+
+			return DBUS_HANDLER_RESULT_HANDLED;
+		}
+	} else if (dbus_message_is_method_call(
+			   m,
+			   "org.freedesktop.DBus.Introspectable",
+			   "Introspect")) {
+			    const char *i = introspection;
+
+		if (!(reply = dbus_message_new_method_return(m)))
+			goto oom;
+
+		if (!dbus_message_append_args(reply,
+					DBUS_TYPE_STRING, &i,
+					DBUS_TYPE_INVALID))
+			goto oom;
+
+		if (!dbus_connection_send(c, reply, NULL))
+			goto oom;
+
+		dbus_message_unref(reply);
+
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+invalid:
+	if (!(reply = dbus_message_new_error(m,
+					DBUS_ERROR_INVALID_ARGS,
+					"Invalid arguments")))
+		goto oom;
+
+	if (!dbus_connection_send(c, reply, NULL))
+		goto oom;
+
+	dbus_message_unref(reply);
+
+	dbus_error_free(&error);
+
+	return DBUS_HANDLER_RESULT_HANDLED;
+
+oom:
+	if (reply)
+		dbus_message_unref(reply);
+
+	dbus_error_free(&error);
+
+	return DBUS_HANDLER_RESULT_NEED_MEMORY;
+}
+
+static const struct DBusObjectPathVTable vtable ={
+	.message_function = object_handler
+};
+
+static DBusHandlerResult filter_handler(DBusConnection *c, DBusMessage *m, void *userdata)
+{
+	struct rd_device *d = userdata;
+	DBusError error;
+	const char *name;
+
+	dbus_error_init(&error);
+
+	if (dbus_message_is_signal(m, "org.freedesktop.DBus", "NameAcquired")) {
+		if (!dbus_message_get_args( m, &error,
+			    DBUS_TYPE_STRING, &name,
+			    DBUS_TYPE_INVALID))
+			goto invalid;
+
+		if (!spa_streq(name, d->service_name))
+			goto invalid;
+
+		pw_log_debug("%p: acquired %s, %s", d, name, d->service_name);
+
+		d->owning = true;
+
+		if (!d->registered) {
+			if (!(dbus_connection_register_object_path(d->connection,
+							d->object_path,
+							&vtable,
+							d)))
+				goto invalid;
+
+			if (!spa_streq(name, d->service_name))
+				goto invalid;
+
+			d->registered = true;
+
+			if (d->callbacks->acquired)
+				d->callbacks->acquired(d->data, d);
+		}
+	} else if (dbus_message_is_signal(m, "org.freedesktop.DBus", "NameLost")) {
+		if (!dbus_message_get_args( m, &error,
+			    DBUS_TYPE_STRING, &name,
+			    DBUS_TYPE_INVALID))
+			goto invalid;
+
+		if (!spa_streq(name, d->service_name))
+			goto invalid;
+
+		pw_log_debug("%p: lost %s", d, name);
+
+		d->owning = false;
+
+		if (d->registered) {
+			dbus_connection_unregister_object_path(d->connection,
+					d->object_path);
+			d->registered = false;
+		}
+	}
+	if (dbus_message_is_signal(m, "org.freedesktop.DBus", "NameOwnerChanged")) {
+		const char *old, *new;
+		if (!dbus_message_get_args( m, &error,
+			    DBUS_TYPE_STRING, &name,
+			    DBUS_TYPE_STRING, &old,
+			    DBUS_TYPE_STRING, &new,
+			    DBUS_TYPE_INVALID))
+			goto invalid;
+
+		if (!spa_streq(name, d->service_name) || d->owning)
+			goto invalid;
+
+		pw_log_debug("%p: changed %s: %s -> %s", d, name, old, new);
+
+		if (old == NULL || *old == 0) {
+			if (d->callbacks->busy && !d->acquiring)
+				d->callbacks->busy(d->data, d, name, 0);
+		} else {
+			if (d->callbacks->available)
+				d->callbacks->available(d->data, d, name);
+		}
+	}
+
+invalid:
+	dbus_error_free(&error);
+	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+struct rd_device *
+rd_device_new(DBusConnection *connection, const char *device_name, const char *application_name,
+		int32_t priority, const struct rd_device_callbacks *callbacks, void *data)
+{
+	struct rd_device *d;
+	int res;
+
+	d = calloc(1, sizeof(struct rd_device));
+	if (d == NULL)
+		return NULL;
+
+	d->connection = connection;
+	d->priority = priority;
+	d->callbacks = callbacks;
+	d->data = data;
+
+	d->application_name = strdup(application_name);
+
+	d->object_path = spa_aprintf(OBJECT_PREFIX "%s", device_name);
+	if (d->object_path == NULL) {
+		res = -errno;
+		goto error_free;
+	}
+	d->service_name = spa_aprintf(SERVICE_PREFIX "%s", device_name);
+	if (d->service_name == NULL) {
+		res = -errno;
+		goto error_free;
+	}
+
+	if (!dbus_connection_add_filter(d->connection,
+				filter_handler,
+				d,
+				NULL)) {
+		res = -ENOMEM;
+		goto error_free;
+	}
+	dbus_bus_add_match(d->connection,
+                        "type='signal',sender='org.freedesktop.DBus',"
+                        "interface='org.freedesktop.DBus',member='NameLost'", NULL);
+	dbus_bus_add_match(d->connection,
+                        "type='signal',sender='org.freedesktop.DBus',"
+                        "interface='org.freedesktop.DBus',member='NameAcquired'", NULL);
+	dbus_bus_add_match(d->connection,
+                        "type='signal',sender='org.freedesktop.DBus',"
+                        "interface='org.freedesktop.DBus',member='NameOwnerChanged'", NULL);
+
+	dbus_connection_ref(d->connection);
+
+	pw_log_debug("%p: new device %s", d, device_name);
+
+	return d;
+
+error_free:
+	free(d->service_name);
+	free(d->object_path);
+	free(d);
+	errno = -res;
+	return NULL;
+}
+
+int rd_device_acquire(struct rd_device *d)
+{
+	int res;
+	DBusError error;
+
+	dbus_error_init(&error);
+
+	pw_log_debug("%p: reserve %s", d, d->service_name);
+
+	d->acquiring = true;
+
+	if ((res = dbus_bus_request_name(d->connection,
+					d->service_name,
+					(d->priority < INT32_MAX ? DBUS_NAME_FLAG_ALLOW_REPLACEMENT : 0),
+					&error)) < 0) {
+			pw_log_warn("%p: reserve failed: %s", d, error.message);
+			dbus_error_free(&error);
+			return -EIO;
+	}
+
+	pw_log_debug("%p: reserve result: %d", d, res);
+
+	if (res == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER ||
+	    res == DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER)
+		return 0;
+
+	if (res == DBUS_REQUEST_NAME_REPLY_EXISTS ||
+	    res == DBUS_REQUEST_NAME_REPLY_IN_QUEUE)
+		return -EBUSY;
+
+	return -EIO;
+}
+
+int rd_device_request_release(struct rd_device *d)
+{
+	DBusMessage *m = NULL;
+
+	if (d->priority <= INT32_MIN)
+		return -EBUSY;
+
+	if ((m = dbus_message_new_method_call(d->service_name,
+					d->object_path,
+					"org.freedesktop.ReserveDevice1",
+					"RequestRelease")) == NULL) {
+		return -ENOMEM;
+	}
+        if (!dbus_message_append_args(m,
+				DBUS_TYPE_INT32, &d->priority,
+				DBUS_TYPE_INVALID)) {
+		dbus_message_unref(m);
+		return -ENOMEM;
+        }
+	if (!dbus_connection_send(d->connection, m, NULL)) {
+		return -EIO;
+	}
+	return 0;
+}
+
+int rd_device_complete_release(struct rd_device *d, int res)
+{
+	dbus_bool_t ret = res != 0;
+
+	if (d->reply == NULL)
+		return -EINVAL;
+
+	pw_log_debug("%p: complete release %d", d, res);
+
+	if (!dbus_message_append_args(d->reply,
+				DBUS_TYPE_BOOLEAN, &ret,
+				DBUS_TYPE_INVALID)) {
+		res = -ENOMEM;
+		goto exit;
+	}
+
+	if (!dbus_connection_send(d->connection, d->reply, NULL)) {
+		res = -EIO;
+		goto exit;
+	}
+	res = 0;
+exit:
+	dbus_message_unref(d->reply);
+	d->reply = NULL;
+	return res;
+}
+
+void rd_device_release(struct rd_device *d)
+{
+	pw_log_debug("%p: release %d", d, d->owning);
+
+	if (d->owning) {
+		DBusError error;
+		dbus_error_init(&error);
+
+		dbus_bus_release_name(d->connection,
+				d->service_name, &error);
+		dbus_error_free(&error);
+	}
+	d->acquiring = false;
+}
+
+void rd_device_destroy(struct rd_device *d)
+{
+	dbus_connection_remove_filter(d->connection,
+			filter_handler, d);
+
+	if (d->registered)
+		dbus_connection_unregister_object_path(d->connection,
+				d->object_path);
+
+	rd_device_release(d);
+
+	free(d->service_name);
+	free(d->object_path);
+	free(d->application_name);
+	free(d->application_device_name);
+	if (d->reply)
+		dbus_message_unref(d->reply);
+
+	dbus_connection_unref(d->connection);
+
+	free(d);
+}
+
+int rd_device_set_application_device_name(struct rd_device *d, const char *name)
+{
+	char *t;
+
+	if (!d)
+		return -EINVAL;
+
+	if (!(t = strdup(name)))
+		return -ENOMEM;
+
+	free(d->application_device_name);
+	d->application_device_name = t;
+
+	return 0;
+}
diff --git a/src/tools/reserve.h b/src/tools/reserve.h
new file mode 100644
index 0000000..c31e2d0
--- /dev/null
+++ b/src/tools/reserve.h
@@ -0,0 +1,82 @@
+/* DBus device reservation API
+ *
+ * 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.
+ */
+
+#ifndef DEVICE_RESERVE_H
+#define DEVICE_RESERVE_H
+
+#include <dbus/dbus.h>
+#include <inttypes.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct rd_device;
+
+struct rd_device_callbacks {
+	/** the device is acquired by us */
+	void (*acquired) (void *data, struct rd_device *d);
+	/** request a release of the device */
+	void (*release) (void *data, struct rd_device *d, int forced);
+	/** the device is busy by someone else */
+	void (*busy) (void *data, struct rd_device *d, const char *name, int32_t priority);
+	/** the device is made available by someone else */
+	void (*available) (void *data, struct rd_device *d, const char *name);
+};
+
+/* create a new device and start watching */
+struct rd_device *
+rd_device_new(DBusConnection *connection,		/**< Bus to watch */
+		const char *device_name,		/**< The device to lock, e.g. "Audio0" */
+		const char *application_name,		/**< A human readable name of the application,
+							  *  e.g. "PipeWire Server" */
+		int32_t priority,			/**< The priority for this application.
+							  *  If unsure use 0 */
+		const struct rd_device_callbacks *callbacks,	/**< Called when device name is acquired/released */
+		void *data);
+
+/** try to acquire the device */
+int rd_device_acquire(struct rd_device *d);
+
+/** request the owner to release the device */
+int rd_device_request_release(struct rd_device *d);
+
+/** complete the release of the device */
+int rd_device_complete_release(struct rd_device *d, int res);
+
+/** release a device */
+void rd_device_release(struct rd_device *d);
+
+/** destroy a device */
+void rd_device_destroy(struct rd_device *d);
+
+/* Set the application device name for an rd_device object. Returns 0
+ * on success, a negative errno style return value on error. */
+int rd_device_set_application_device_name(struct rd_device *d, const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif