service/pipewire: add pipewire module

.clang-tidy

@@ -36,6 +36,7 @@ Checks: >
   -readability-braces-around-statements,
   -readability-redundant-access-specifiers,
   -readability-else-after-return,
+  -readability-container-data-pointer,
   tidyfox-*,
 CheckOptions:
   performance-for-range-copy.WarnOnAllAutoCopies: true

CMakeLists.txt

@@ -18,6 +18,7 @@ option(HYPRLAND "Support hyprland specific features" ON)
 option(HYPRLAND_GLOBAL_SHORTCUTS "Hyprland Global Shortcuts" ON)
 option(HYPRLAND_FOCUS_GRAB "Hyprland Focus Grabbing" ON)
 option(SERVICE_STATUS_NOTIFIER "StatusNotifierItem service" ON)
+option(SERVICE_PIPEWIRE "PipeWire service" ON)
 
 message(STATUS "Quickshell configuration")
 message(STATUS "  NVIDIA workarounds: ${NVIDIA_COMPAT}")
@@ -30,6 +31,7 @@ if (WAYLAND)
 endif ()
 message(STATUS "  Services")
 message(STATUS "    StatusNotifier: ${SERVICE_STATUS_NOTIFIER}")
+message(STATUS "    PipeWire: ${SERVICE_PIPEWIRE}")
 message(STATUS "  Hyprland: ${HYPRLAND}")
 if (HYPRLAND)
 	message(STATUS "    Focus Grabbing: ${HYPRLAND_FOCUS_GRAB}")

default.nix

@@ -24,6 +24,7 @@
 
   debug ? false,
   enableWayland ? true,
+  enablePipewire ? true,
   nvidiaCompat ? false,
   svgSupport ? true, # you almost always want this
 }: buildStdenv.mkDerivation {
@@ -46,7 +47,8 @@
     qt6.qtdeclarative
   ]
   ++ (lib.optionals enableWayland [ qt6.qtwayland wayland ])
-  ++ (lib.optionals svgSupport [ qt6.qtsvg ]);
+  ++ (lib.optionals svgSupport [ qt6.qtsvg ])
+  ++ (lib.optionals enablePipewire [ pipewire ]);
 
   QTWAYLANDSCANNER = lib.optionalString enableWayland "${qt6.qtwayland}/libexec/qtwaylandscanner";
 
@@ -62,7 +64,8 @@
   cmakeFlags = [
     "-DGIT_REVISION=${gitRev}"
   ] ++ lib.optional (!enableWayland) "-DWAYLAND=OFF"
-  ++ lib.optional nvidiaCompat "-DNVIDIA_COMPAT=ON";
+  ++ lib.optional nvidiaCompat "-DNVIDIA_COMPAT=ON"
+  ++ lib.optional (!enablePipewire) "-DSERVICE_PIPEWIRE=OFF";
 
   buildPhase = "ninjaBuildPhase";
   enableParallelBuilding = true;

docs

@@ -1 +1 @@
-Subproject commit 149b784a5a4c40ada67cb9f6af5a5350678ab6d4
+Subproject commit ff5da84a8b258a9b2caaf978ddb6de23635d8903

src/services/CMakeLists.txt

@@ -1,3 +1,7 @@
 if (SERVICE_STATUS_NOTIFIER)
 	add_subdirectory(status_notifier)
 endif()
+
+if (SERVICE_PIPEWIRE)
+	add_subdirectory(pipewire)
+endif()

src/services/pipewire/CMakeLists.txt

@@ -0,0 +1,24 @@
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(pipewire REQUIRED IMPORTED_TARGET libpipewire-0.3)
+
+qt_add_library(quickshell-service-pipewire STATIC
+	qml.cpp
+	core.cpp
+	connection.cpp
+	registry.cpp
+	node.cpp
+	metadata.cpp
+	link.cpp
+)
+
+qt_add_qml_module(quickshell-service-pipewire
+	URI Quickshell.Services.Pipewire
+	VERSION 0.1
+)
+
+target_link_libraries(quickshell-service-pipewire PRIVATE ${QT_DEPS} PkgConfig::pipewire)
+
+qs_pch(quickshell-service-pipewire)
+qs_pch(quickshell-service-pipewireplugin)
+
+target_link_libraries(quickshell PRIVATE quickshell-service-pipewireplugin)

src/services/pipewire/connection.cpp

@@ -0,0 +1,23 @@
+#include "connection.hpp"
+
+#include <qobject.h>
+
+namespace qs::service::pipewire {
+
+PwConnection::PwConnection(QObject* parent): QObject(parent) {
+	if (this->core.isValid()) {
+		this->registry.init(this->core);
+	}
+}
+
+PwConnection* PwConnection::instance() {
+	static PwConnection* instance = nullptr; // NOLINT
+
+	if (instance == nullptr) {
+		instance = new PwConnection();
+	}
+
+	return instance;
+}
+
+} // namespace qs::service::pipewire

src/services/pipewire/connection.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "core.hpp"
+#include "metadata.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwConnection: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwConnection(QObject* parent = nullptr);
+
+	PwRegistry registry;
+	PwDefaultsMetadata defaults {&this->registry};
+
+	static PwConnection* instance();
+
+private:
+	// init/destroy order is important. do not rearrange.
+	PwCore core;
+};
+
+} // namespace qs::service::pipewire

src/services/pipewire/core.cpp

@@ -0,0 +1,87 @@
+#include "core.hpp"
+#include <cerrno>
+
+#include <pipewire/context.h>
+#include <pipewire/core.h>
+#include <pipewire/loop.h>
+#include <pipewire/pipewire.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qsocketnotifier.h>
+#include <spa/utils/defs.h>
+#include <spa/utils/hook.h>
+
+namespace qs::service::pipewire {
+
+Q_LOGGING_CATEGORY(logLoop, "quickshell.service.pipewire.loop", QtWarningMsg);
+
+PwCore::PwCore(QObject* parent): QObject(parent), notifier(QSocketNotifier::Read) {
+	qCInfo(logLoop) << "Creating pipewire event loop.";
+	pw_init(nullptr, nullptr);
+
+	this->loop = pw_loop_new(nullptr);
+	if (this->loop == nullptr) {
+		qCCritical(logLoop) << "Failed to create pipewire event loop.";
+		return;
+	}
+
+	this->context = pw_context_new(this->loop, nullptr, 0);
+	if (this->context == nullptr) {
+		qCCritical(logLoop) << "Failed to create pipewire context.";
+		return;
+	}
+
+	qCInfo(logLoop) << "Connecting to pipewire server.";
+	this->core = pw_context_connect(this->context, nullptr, 0);
+	if (this->core == nullptr) {
+		qCCritical(logLoop) << "Failed to connect pipewire context. Errno:" << errno;
+		return;
+	}
+
+	qCInfo(logLoop) << "Linking pipewire event loop.";
+	// Tie the pw event loop into qt.
+	auto fd = pw_loop_get_fd(this->loop);
+	this->notifier.setSocket(fd);
+	QObject::connect(&this->notifier, &QSocketNotifier::activated, this, &PwCore::poll);
+	this->notifier.setEnabled(true);
+}
+
+PwCore::~PwCore() {
+	qCInfo(logLoop) << "Destroying PwCore.";
+
+	if (this->loop != nullptr) {
+		if (this->context != nullptr) {
+			if (this->core != nullptr) {
+				pw_core_disconnect(this->core);
+			}
+
+			pw_context_destroy(this->context);
+		}
+
+		pw_loop_destroy(this->loop);
+	}
+}
+
+bool PwCore::isValid() const {
+	// others must init first
+	return this->core != nullptr;
+}
+
+void PwCore::poll() const {
+	qCDebug(logLoop) << "Pipewire event loop received new events, iterating.";
+	// Spin pw event loop.
+	pw_loop_iterate(this->loop, 0);
+	qCDebug(logLoop) << "Done iterating pipewire event loop.";
+}
+
+SpaHook::SpaHook() { // NOLINT
+	spa_zero(this->hook);
+}
+
+void SpaHook::remove() {
+	spa_hook_remove(&this->hook);
+	spa_zero(this->hook);
+}
+
+} // namespace qs::service::pipewire

src/services/pipewire/core.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <pipewire/context.h>
+#include <pipewire/core.h>
+#include <pipewire/loop.h>
+#include <pipewire/proxy.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qsocketnotifier.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/utils/hook.h>
+
+namespace qs::service::pipewire {
+
+class PwCore: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwCore(QObject* parent = nullptr);
+	~PwCore() override;
+	Q_DISABLE_COPY_MOVE(PwCore);
+
+	[[nodiscard]] bool isValid() const;
+
+	pw_loop* loop = nullptr;
+	pw_context* context = nullptr;
+	pw_core* core = nullptr;
+
+private slots:
+	void poll() const;
+
+private:
+	QSocketNotifier notifier;
+};
+
+template <typename T>
+class PwObject {
+public:
+	explicit PwObject(T* object = nullptr): object(object) {}
+	~PwObject() {
+		pw_proxy_destroy(reinterpret_cast<pw_proxy*>(this->object)); // NOLINT
+	}
+
+	Q_DISABLE_COPY_MOVE(PwObject);
+
+	T* object;
+};
+
+class SpaHook {
+public:
+	explicit SpaHook();
+
+	void remove();
+	spa_hook hook;
+};
+
+} // namespace qs::service::pipewire

src/services/pipewire/link.cpp

@@ -0,0 +1,184 @@
+#include "link.hpp"
+#include <cstring>
+
+#include <pipewire/link.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/utils/dict.h>
+
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+Q_LOGGING_CATEGORY(logLink, "quickshell.service.pipewire.link", QtWarningMsg);
+
+QString PwLinkState::toString(Enum value) {
+	return QString(pw_link_state_as_string(static_cast<pw_link_state>(value)));
+}
+
+void PwLink::bindHooks() {
+	pw_link_add_listener(this->proxy(), &this->listener.hook, &PwLink::EVENTS, this);
+}
+
+void PwLink::unbindHooks() {
+	this->listener.remove();
+	this->setState(PW_LINK_STATE_UNLINKED);
+}
+
+void PwLink::initProps(const spa_dict* props) {
+	qCDebug(logLink) << "Parsing initial SPA props of link" << this;
+
+	const spa_dict_item* item = nullptr;
+	spa_dict_for_each(item, props) {
+		if (strcmp(item->key, "link.output.node") == 0) {
+			auto str = QString(item->value);
+			auto ok = false;
+			auto value = str.toInt(&ok);
+			if (ok) this->setOutputNode(value);
+			else {
+				qCWarning(logLink) << "Could not parse link.output.node for" << this << ":" << item->value;
+			}
+		} else if (strcmp(item->key, "link.input.node") == 0) {
+			auto str = QString(item->value);
+			auto ok = false;
+			auto value = str.toInt(&ok);
+			if (ok) this->setInputNode(value);
+			else {
+				qCWarning(logLink) << "Could not parse link.input.node for" << this << ":" << item->value;
+			}
+		}
+	}
+}
+
+const pw_link_events PwLink::EVENTS = {
+    .version = PW_VERSION_LINK_EVENTS,
+    .info = &PwLink::onInfo,
+};
+
+void PwLink::onInfo(void* data, const struct pw_link_info* info) {
+	auto* self = static_cast<PwLink*>(data);
+	qCDebug(logLink) << "Got link info update for" << self << "with mask" << info->change_mask;
+	self->setOutputNode(info->output_node_id);
+	self->setInputNode(info->input_node_id);
+
+	if ((info->change_mask & PW_LINK_CHANGE_MASK_STATE) != 0) {
+		self->setState(info->state);
+	}
+}
+
+quint32 PwLink::outputNode() const { return this->mOutputNode; }
+quint32 PwLink::inputNode() const { return this->mInputNode; }
+PwLinkState::Enum PwLink::state() const { return static_cast<PwLinkState::Enum>(this->mState); }
+
+void PwLink::setOutputNode(quint32 outputNode) {
+	if (outputNode == this->mOutputNode) return;
+
+	if (this->mOutputNode != 0) {
+		qCWarning(logLink) << "Got unexpected output node update for" << this << "to" << outputNode;
+	}
+
+	this->mOutputNode = outputNode;
+	qCDebug(logLink) << "Updated output node of" << this;
+}
+
+void PwLink::setInputNode(quint32 inputNode) {
+	if (inputNode == this->mInputNode) return;
+
+	if (this->mInputNode != 0) {
+		qCWarning(logLink) << "Got unexpected input node update for" << this << "to" << inputNode;
+	}
+
+	this->mInputNode = inputNode;
+	qCDebug(logLink) << "Updated input node of" << this;
+}
+
+void PwLink::setState(pw_link_state state) {
+	if (state == this->mState) return;
+
+	this->mState = state;
+	qCDebug(logLink) << "Updated state of" << this;
+	emit this->stateChanged();
+}
+
+QDebug operator<<(QDebug debug, const PwLink* link) {
+	if (link == nullptr) {
+		debug << "PwLink(0x0)";
+	} else {
+		auto saver = QDebugStateSaver(debug);
+		debug.nospace() << "PwLink(" << link->outputNode() << " -> " << link->inputNode() << ", "
+		                << static_cast<const void*>(link) << ", id=";
+		link->debugId(debug);
+		debug << ", state=" << link->state() << ')';
+	}
+
+	return debug;
+}
+
+PwLinkGroup::PwLinkGroup(PwLink* firstLink, QObject* parent)
+    : QObject(parent)
+    , mOutputNode(firstLink->outputNode())
+    , mInputNode(firstLink->inputNode()) {
+	this->tryAddLink(firstLink);
+}
+
+void PwLinkGroup::ref() {
+	this->refcount++;
+
+	if (this->refcount == 1) {
+		this->trackedLink = *this->links.begin();
+		this->trackedLink->ref();
+		QObject::connect(this->trackedLink, &PwLink::stateChanged, this, &PwLinkGroup::stateChanged);
+		emit this->stateChanged();
+	}
+}
+
+void PwLinkGroup::unref() {
+	if (this->refcount == 0) return;
+	this->refcount--;
+
+	if (this->refcount == 0) {
+		this->trackedLink->unref();
+		this->trackedLink = nullptr;
+		emit this->stateChanged();
+	}
+}
+
+quint32 PwLinkGroup::outputNode() const { return this->mOutputNode; }
+
+quint32 PwLinkGroup::inputNode() const { return this->mInputNode; }
+
+PwLinkState::Enum PwLinkGroup::state() const {
+	if (this->trackedLink == nullptr) {
+		return PwLinkState::Unlinked;
+	} else {
+		return this->trackedLink->state();
+	}
+}
+
+bool PwLinkGroup::tryAddLink(PwLink* link) {
+	if (link->outputNode() != this->mOutputNode || link->inputNode() != this->mInputNode)
+		return false;
+
+	this->links.insert(link->id, link);
+	QObject::connect(link, &PwBindableObject::destroying, this, &PwLinkGroup::onLinkRemoved);
+	return true;
+}
+
+void PwLinkGroup::onLinkRemoved(QObject* object) {
+	auto* link = static_cast<PwLink*>(object); // NOLINT
+	this->links.remove(link->id);
+
+	if (this->links.empty()) {
+		delete this;
+	} else if (link == this->trackedLink) {
+		this->trackedLink = *this->links.begin();
+		QObject::connect(this->trackedLink, &PwLink::stateChanged, this, &PwLinkGroup::stateChanged);
+		emit this->stateChanged();
+	}
+}
+
+} // namespace qs::service::pipewire

src/services/pipewire/link.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <pipewire/link.h>
+#include <pipewire/type.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwLinkState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum {
+		Error = PW_LINK_STATE_ERROR,
+		Unlinked = PW_LINK_STATE_UNLINKED,
+		Init = PW_LINK_STATE_INIT,
+		Negotiating = PW_LINK_STATE_NEGOTIATING,
+		Allocating = PW_LINK_STATE_ALLOCATING,
+		Paused = PW_LINK_STATE_PAUSED,
+		Active = PW_LINK_STATE_ACTIVE,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(PwLinkState::Enum value);
+};
+
+constexpr const char TYPE_INTERFACE_Link[] = PW_TYPE_INTERFACE_Link;             // NOLINT
+class PwLink: public PwBindable<pw_link, TYPE_INTERFACE_Link, PW_VERSION_LINK> { // NOLINT
+	Q_OBJECT;
+
+public:
+	void bindHooks() override;
+	void unbindHooks() override;
+	void initProps(const spa_dict* props) override;
+
+	[[nodiscard]] quint32 outputNode() const;
+	[[nodiscard]] quint32 inputNode() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+signals:
+	void stateChanged();
+
+private:
+	static const pw_link_events EVENTS;
+	static void onInfo(void* data, const struct pw_link_info* info);
+
+	void setOutputNode(quint32 outputNode);
+	void setInputNode(quint32 inputNode);
+	void setState(pw_link_state state);
+
+	SpaHook listener;
+
+	quint32 mOutputNode = 0;
+	quint32 mInputNode = 0;
+	pw_link_state mState = PW_LINK_STATE_UNLINKED;
+};
+
+QDebug operator<<(QDebug debug, const PwLink* link);
+
+class PwLinkGroup: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwLinkGroup(PwLink* firstLink, QObject* parent = nullptr);
+
+	void ref();
+	void unref();
+
+	[[nodiscard]] quint32 outputNode() const;
+	[[nodiscard]] quint32 inputNode() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+	QHash<quint32, PwLink*> links;
+
+	bool tryAddLink(PwLink* link);
+
+signals:
+	void stateChanged();
+
+private slots:
+	void onLinkRemoved(QObject* object);
+
+private:
+	quint32 mOutputNode = 0;
+	quint32 mInputNode = 0;
+	PwLink* trackedLink = nullptr;
+	quint32 refcount = 0;
+};
+
+} // namespace qs::service::pipewire

src/services/pipewire/metadata.cpp

@@ -0,0 +1,146 @@
+#include "metadata.hpp"
+#include <array>
+#include <cstring>
+
+#include <pipewire/extensions/metadata.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/utils/json.h>
+
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+Q_LOGGING_CATEGORY(logMeta, "quickshell.service.pipewire.metadata", QtWarningMsg);
+
+void PwMetadata::bindHooks() {
+	pw_metadata_add_listener(this->proxy(), &this->listener.hook, &PwMetadata::EVENTS, this);
+}
+
+void PwMetadata::unbindHooks() { this->listener.remove(); }
+
+const pw_metadata_events PwMetadata::EVENTS = {
+    .version = PW_VERSION_METADATA_EVENTS,
+    .property = &PwMetadata::onProperty,
+};
+
+int PwMetadata::onProperty(
+    void* data,
+    quint32 subject,
+    const char* key,
+    const char* type,
+    const char* value
+) {
+	auto* self = static_cast<PwMetadata*>(data);
+	qCDebug(logMeta) << "Received metadata for" << self << "- subject:" << subject
+	                 << "key:" << QString(key) << "type:" << QString(type)
+	                 << "value:" << QString(value);
+
+	emit self->registry->metadataUpdate(self, subject, key, type, value);
+
+	// ideally we'd dealloc metadata that wasn't picked up but there's no information
+	// available about if updates can come in later, so I assume they can.
+
+	return 0; // ??? - no docs and no reason for a callback to return an int
+}
+
+PwDefaultsMetadata::PwDefaultsMetadata(PwRegistry* registry) {
+	QObject::connect(
+	    registry,
+	    &PwRegistry::metadataUpdate,
+	    this,
+	    &PwDefaultsMetadata::onMetadataUpdate
+	);
+}
+
+QString PwDefaultsMetadata::defaultSink() const { return this->mDefaultSink; }
+
+QString PwDefaultsMetadata::defaultSource() const { return this->mDefaultSource; }
+
+// we don't really care if the metadata objects are destroyed, but try to ref them so we get property updates
+void PwDefaultsMetadata::onMetadataUpdate(
+    PwMetadata* metadata,
+    quint32 subject,
+    const char* key,
+    const char* /*type*/,
+    const char* value
+) {
+	if (subject != 0) return;
+
+	// non "configured" sinks and sources have lower priority as wireplumber seems to only change
+	// the "configured" ones.
+
+	bool sink = false;
+	if (strcmp(key, "default.configured.audio.sink") == 0) {
+		sink = true;
+		this->sinkConfigured = true;
+	} else if ((!this->sinkConfigured && strcmp(key, "default.audio.sink") == 0)) {
+		sink = true;
+	}
+
+	if (sink) {
+		this->defaultSinkHolder.setObject(metadata);
+
+		auto newSink = PwDefaultsMetadata::parseNameSpaJson(value);
+		qCInfo(logMeta) << "Got default sink" << newSink << "configured:" << this->sinkConfigured;
+		if (newSink == this->mDefaultSink) return;
+
+		this->mDefaultSink = newSink;
+		emit this->defaultSinkChanged();
+		return;
+	}
+
+	bool source = false;
+	if (strcmp(key, "default.configured.audio.source") == 0) {
+		source = true;
+		this->sourceConfigured = true;
+	} else if ((!this->sourceConfigured && strcmp(key, "default.audio.source") == 0)) {
+		source = true;
+	}
+
+	if (source) {
+		this->defaultSourceHolder.setObject(metadata);
+
+		auto newSource = PwDefaultsMetadata::parseNameSpaJson(value);
+		qCInfo(logMeta) << "Got default source" << newSource << "configured:" << this->sourceConfigured;
+		if (newSource == this->mDefaultSource) return;
+
+		this->mDefaultSource = newSource;
+		emit this->defaultSourceChanged();
+		return;
+	}
+}
+
+QString PwDefaultsMetadata::parseNameSpaJson(const char* spaJson) {
+	auto iter = std::array<spa_json, 2>();
+	spa_json_init(&iter[0], spaJson, strlen(spaJson));
+
+	if (spa_json_enter_object(&iter[0], &iter[1]) < 0) {
+		qCWarning(logMeta) << "Failed to parse source/sink SPA json - failed to enter object of"
+		                   << QString(spaJson);
+		return "";
+	}
+
+	auto buf = std::array<char, 512>();
+	while (spa_json_get_string(&iter[1], buf.data(), buf.size()) > 0) {
+		if (strcmp(buf.data(), "name") != 0) continue;
+
+		if (spa_json_get_string(&iter[1], buf.data(), buf.size()) < 0) {
+			qCWarning(logMeta
+			) << "Failed to parse source/sink SPA json - failed to read value of name property"
+			  << QString(spaJson);
+			return "";
+		}
+
+		return QString(buf.data());
+	}
+
+	qCWarning(logMeta) << "Failed to parse source/sink SPA json - failed to find name property of"
+	                   << QString(spaJson);
+	return "";
+}
+
+} // namespace qs::service::pipewire

src/services/pipewire/metadata.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <pipewire/extensions/metadata.h>
+#include <pipewire/type.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "core.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+constexpr const char TYPE_INTERFACE_Metadata[] = PW_TYPE_INTERFACE_Metadata; // NOLINT
+class PwMetadata
+    : public PwBindable<pw_metadata, TYPE_INTERFACE_Metadata, PW_VERSION_METADATA> { // NOLINT
+	Q_OBJECT;
+
+public:
+	void bindHooks() override;
+	void unbindHooks() override;
+
+private:
+	static const pw_metadata_events EVENTS;
+	static int
+	onProperty(void* data, quint32 subject, const char* key, const char* type, const char* value);
+
+	SpaHook listener;
+};
+
+class PwDefaultsMetadata: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwDefaultsMetadata(PwRegistry* registry);
+
+	[[nodiscard]] QString defaultSource() const;
+	[[nodiscard]] QString defaultSink() const;
+
+signals:
+	void defaultSourceChanged();
+	void defaultSinkChanged();
+
+private slots:
+	void onMetadataUpdate(
+	    PwMetadata* metadata,
+	    quint32 subject,
+	    const char* key,
+	    const char* type,
+	    const char* value
+	);
+
+private:
+	static QString parseNameSpaJson(const char* spaJson);
+
+	PwBindableRef<PwMetadata> defaultSinkHolder;
+	PwBindableRef<PwMetadata> defaultSourceHolder;
+
+	bool sinkConfigured = false;
+	QString mDefaultSink;
+	bool sourceConfigured = false;
+	QString mDefaultSource;
+};
+
+} // namespace qs::service::pipewire

src/services/pipewire/node.cpp

@@ -0,0 +1,384 @@
+#include "node.hpp"
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+
+#include <pipewire/core.h>
+#include <pipewire/node.h>
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/node/keys.h>
+#include <spa/param/param.h>
+#include <spa/param/props.h>
+#include <spa/pod/builder.h>
+#include <spa/pod/iter.h>
+#include <spa/pod/pod.h>
+#include <spa/pod/vararg.h>
+#include <spa/utils/dict.h>
+#include <spa/utils/keys.h>
+#include <spa/utils/type.h>
+
+namespace qs::service::pipewire {
+
+Q_LOGGING_CATEGORY(logNode, "quickshell.service.pipewire.node", QtWarningMsg);
+
+QString PwAudioChannel::toString(Enum value) {
+	switch (value) {
+	case Unknown: return "Unknown";
+	case NA: return "N/A";
+	case Mono: return "Mono";
+	case FrontCenter: return "Front Center";
+	case FrontLeft: return "Front Left";
+	case FrontRight: return "Front Right";
+	case FrontLeftCenter: return "Front Left Center";
+	case FrontRightCenter: return "Front Right Center";
+	case FrontLeftWide: return "Front Left Wide";
+	case FrontRightWide: return "Front Right Wide";
+	case FrontCenterHigh: return "Front Center High";
+	case FrontLeftHigh: return "Front Left High";
+	case FrontRightHigh: return "Front Right High";
+	case LowFrequencyEffects: return "Low Frequency Effects";
+	case LowFrequencyEffects2: return "Low Frequency Effects 2";
+	case LowFrequencyEffectsLeft: return "Low Frequency Effects Left";
+	case LowFrequencyEffectsRight: return "Low Frequency Effects Right";
+	case SideLeft: return "Side Left";
+	case SideRight: return "Side Right";
+	case RearCenter: return "Rear Center";
+	case RearLeft: return "Rear Left";
+	case RearRight: return "Rear Right";
+	case RearLeftCenter: return "Rear Left Center";
+	case RearRightCenter: return "Rear Right Center";
+	case TopCenter: return "Top Center";
+	case TopFrontCenter: return "Top Front Center";
+	case TopFrontLeft: return "Top Front Left";
+	case TopFrontRight: return "Top Front Right";
+	case TopFrontLeftCenter: return "Top Front Left Center";
+	case TopFrontRightCenter: return "Top Front Right Center";
+	case TopSideLeft: return "Top Side Left";
+	case TopSideRight: return "Top Side Right";
+	case TopRearCenter: return "Top Rear Center";
+	case TopRearLeft: return "Top Rear Left";
+	case TopRearRight: return "Top Rear Right";
+	case BottomCenter: return "Bottom Center";
+	case BottomLeftCenter: return "Bottom Left Center";
+	case BottomRightCenter: return "Bottom Right Center";
+	default:
+		if (value >= AuxRangeStart && value <= AuxRangeEnd) {
+			return QString("Aux %1").arg(value - AuxRangeStart + 1);
+		} else if (value >= CustomRangeStart) {
+			return QString("Custom %1").arg(value - CustomRangeStart + 1);
+		} else {
+			return "Unknown";
+		}
+	}
+}
+
+void PwNode::bindHooks() {
+	pw_node_add_listener(this->proxy(), &this->listener.hook, &PwNode::EVENTS, this);
+}
+
+void PwNode::unbindHooks() {
+	this->listener.remove();
+	this->properties.clear();
+	emit this->propertiesChanged();
+
+	if (this->boundData != nullptr) {
+		this->boundData->onUnbind();
+	}
+}
+
+void PwNode::initProps(const spa_dict* props) {
+	if (const auto* mediaClass = spa_dict_lookup(props, SPA_KEY_MEDIA_CLASS)) {
+		if (strcmp(mediaClass, "Audio/Sink") == 0) {
+			this->type = PwNodeType::Audio;
+			this->isSink = true;
+			this->isStream = false;
+		} else if (strcmp(mediaClass, "Audio/Source") == 0) {
+			this->type = PwNodeType::Audio;
+			this->isSink = false;
+			this->isStream = false;
+		} else if (strcmp(mediaClass, "Stream/Output/Audio") == 0) {
+			this->type = PwNodeType::Audio;
+			this->isSink = false;
+			this->isStream = true;
+		} else if (strcmp(mediaClass, "Stream/Input/Audio") == 0) {
+			this->type = PwNodeType::Audio;
+			this->isSink = true;
+			this->isStream = true;
+		}
+	}
+
+	if (const auto* nodeName = spa_dict_lookup(props, SPA_KEY_NODE_NAME)) {
+		this->name = nodeName;
+	}
+
+	if (const auto* nodeDesc = spa_dict_lookup(props, SPA_KEY_NODE_DESCRIPTION)) {
+		this->description = nodeDesc;
+	}
+
+	if (const auto* nodeNick = spa_dict_lookup(props, "node.nick")) {
+		this->nick = nodeNick;
+	}
+
+	if (this->type == PwNodeType::Audio) {
+		this->boundData = new PwNodeBoundAudio(this);
+	}
+}
+
+const pw_node_events PwNode::EVENTS = {
+    .version = PW_VERSION_NODE_EVENTS,
+    .info = &PwNode::onInfo,
+    .param = &PwNode::onParam,
+};
+
+void PwNode::onInfo(void* data, const pw_node_info* info) {
+	auto* self = static_cast<PwNode*>(data);
+
+	if ((info->change_mask & PW_NODE_CHANGE_MASK_PROPS) != 0) {
+		auto properties = QMap<QString, QString>();
+
+		const spa_dict_item* item = nullptr;
+		spa_dict_for_each(item, info->props) { properties.insert(item->key, item->value); }
+
+		self->properties = properties;
+		emit self->propertiesChanged();
+	}
+
+	if (self->boundData != nullptr) {
+		self->boundData->onInfo(info);
+	}
+}
+
+void PwNode::onParam(
+    void* data,
+    qint32 /*seq*/,
+    quint32 id,
+    quint32 index,
+    quint32 /*next*/,
+    const spa_pod* param
+) {
+	auto* self = static_cast<PwNode*>(data);
+	if (self->boundData != nullptr) {
+		self->boundData->onSpaParam(id, index, param);
+	}
+}
+
+void PwNodeBoundAudio::onInfo(const pw_node_info* info) {
+	if ((info->change_mask & PW_NODE_CHANGE_MASK_PARAMS) != 0) {
+		for (quint32 i = 0; i < info->n_params; i++) {
+			auto& param = info->params[i]; // NOLINT
+
+			if (param.id == SPA_PARAM_Props && (param.flags & SPA_PARAM_INFO_READ) != 0) {
+				pw_node_enum_params(this->node->proxy(), 0, param.id, 0, UINT32_MAX, nullptr);
+			}
+		}
+	}
+}
+
+void PwNodeBoundAudio::onSpaParam(quint32 id, quint32 index, const spa_pod* param) {
+	if (id == SPA_PARAM_Props && index == 0) {
+		this->updateVolumeFromParam(param);
+		this->updateMutedFromParam(param);
+	}
+}
+
+void PwNodeBoundAudio::updateVolumeFromParam(const spa_pod* param) {
+	const auto* volumesProp = spa_pod_find_prop(param, nullptr, SPA_PROP_channelVolumes);
+	const auto* channelsProp = spa_pod_find_prop(param, nullptr, SPA_PROP_channelMap);
+
+	if (volumesProp == nullptr) {
+		qCWarning(logNode) << "Cannot update volume props of" << this->node
+		                   << "- channelVolumes was null.";
+		return;
+	}
+
+	if (channelsProp == nullptr) {
+		qCWarning(logNode) << "Cannot update volume props of" << this->node << "- channelMap was null.";
+		return;
+	}
+
+	if (spa_pod_is_array(&volumesProp->value) == 0) {
+		qCWarning(logNode) << "Cannot update volume props of" << this->node
+		                   << "- channelVolumes was not an array.";
+		return;
+	}
+
+	if (spa_pod_is_array(&channelsProp->value) == 0) {
+		qCWarning(logNode) << "Cannot update volume props of" << this->node
+		                   << "- channelMap was not an array.";
+		return;
+	}
+
+	const auto* volumes = reinterpret_cast<const spa_pod_array*>(&volumesProp->value);   // NOLINT
+	const auto* channels = reinterpret_cast<const spa_pod_array*>(&channelsProp->value); // NOLINT
+
+	auto volumesVec = QVector<float>();
+	auto channelsVec = QVector<PwAudioChannel::Enum>();
+
+	spa_pod* iter = nullptr;
+	SPA_POD_ARRAY_FOREACH(volumes, iter) {
+		// Cubing behavior found in MPD source, and appears to corrospond to everyone else's measurements correctly.
+		auto linear = *reinterpret_cast<float*>(iter); // NOLINT
+		auto visual = std::cbrt(linear);
+		volumesVec.push_back(visual);
+	}
+
+	SPA_POD_ARRAY_FOREACH(channels, iter) {
+		channelsVec.push_back(*reinterpret_cast<PwAudioChannel::Enum*>(iter)); // NOLINT
+	}
+
+	if (volumesVec.size() != channelsVec.size()) {
+		qCWarning(logNode) << "Cannot update volume props of" << this->node
+		                   << "- channelVolumes and channelMap are not the same size. Sizes:"
+		                   << volumesVec.size() << channelsVec.size();
+		return;
+	}
+
+	// It is important that the lengths of channels and volumes stay in sync whenever you read them.
+	auto channelsChanged = false;
+	auto volumesChanged = false;
+
+	if (this->mChannels != channelsVec) {
+		this->mChannels = channelsVec;
+		channelsChanged = true;
+		qCDebug(logNode) << "Got updated channels of" << this->node << '-' << this->mChannels;
+	}
+
+	if (this->mVolumes != volumesVec) {
+		this->mVolumes = volumesVec;
+		volumesChanged = true;
+		qCDebug(logNode) << "Got updated volumes of" << this->node << '-' << this->mVolumes;
+	}
+
+	if (channelsChanged) emit this->channelsChanged();
+	if (volumesChanged) emit this->volumesChanged();
+}
+
+void PwNodeBoundAudio::updateMutedFromParam(const spa_pod* param) {
+	const auto* mutedProp = spa_pod_find_prop(param, nullptr, SPA_PROP_mute);
+
+	if (mutedProp == nullptr) {
+		qCWarning(logNode) << "Cannot update muted state of" << this->node
+		                   << "- mute property was null.";
+		return;
+	}
+
+	if (spa_pod_is_bool(&mutedProp->value) == 0) {
+		qCWarning(logNode) << "Cannot update muted state of" << this->node
+		                   << "- mute property was not a boolean.";
+		return;
+	}
+
+	bool muted = false;
+	spa_pod_get_bool(&mutedProp->value, &muted);
+
+	if (muted != this->mMuted) {
+		qCDebug(logNode) << "Got updated mute status of" << this->node << '-' << muted;
+		this->mMuted = muted;
+		emit this->mutedChanged();
+	}
+}
+
+void PwNodeBoundAudio::onUnbind() {
+	this->mChannels.clear();
+	this->mVolumes.clear();
+	emit this->channelsChanged();
+	emit this->volumesChanged();
+}
+
+bool PwNodeBoundAudio::isMuted() const { return this->mMuted; }
+
+void PwNodeBoundAudio::setMuted(bool muted) {
+	if (this->node->proxy() == nullptr) {
+		qCWarning(logNode) << "Tried to change mute state for" << this->node << "which is not bound.";
+		return;
+	}
+
+	if (muted == this->mMuted) return;
+
+	auto buffer = std::array<quint32, 1024>();
+	auto builder = SPA_POD_BUILDER_INIT(buffer.data(), buffer.size());
+
+	// is this a leak? seems like probably not? docs don't say, as usual.
+	// clang-format off
+	auto* pod = spa_pod_builder_add_object(
+			&builder, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
+			SPA_PROP_mute, SPA_POD_Bool(muted)
+	);
+	// clang-format on
+
+	qCDebug(logNode) << "Changed muted state of" << this->node << "to" << muted;
+	this->mMuted = muted;
+	pw_node_set_param(this->node->proxy(), SPA_PARAM_Props, 0, static_cast<spa_pod*>(pod));
+	emit this->mutedChanged();
+}
+
+float PwNodeBoundAudio::averageVolume() const {
+	float total = 0;
+
+	for (auto volume: this->mVolumes) {
+		total += volume;
+	}
+
+	return total / static_cast<float>(this->mVolumes.size());
+}
+
+void PwNodeBoundAudio::setAverageVolume(float volume) {
+	auto oldAverage = this->averageVolume();
+	auto mul = oldAverage == 0 ? 0 : volume / oldAverage;
+	auto volumes = QVector<float>();
+
+	for (auto oldVolume: this->mVolumes) {
+		volumes.push_back(mul == 0 ? volume : oldVolume * mul);
+	}
+
+	this->setVolumes(volumes);
+}
+
+QVector<PwAudioChannel::Enum> PwNodeBoundAudio::channels() const { return this->mChannels; }
+
+QVector<float> PwNodeBoundAudio::volumes() const { return this->mVolumes; }
+
+void PwNodeBoundAudio::setVolumes(const QVector<float>& volumes) {
+	if (this->node->proxy() == nullptr) {
+		qCWarning(logNode) << "Tried to change node volumes for" << this->node << "which is not bound.";
+		return;
+	}
+
+	if (volumes == this->mVolumes) return;
+
+	if (volumes.length() != this->mVolumes.length()) {
+		qCWarning(logNode) << "Tried to change node volumes for" << this->node << "from"
+		                   << this->mVolumes << "to" << volumes
+		                   << "which has a different length than the list of channels"
+		                   << this->mChannels;
+		return;
+	}
+
+	auto buffer = std::array<quint32, 1024>();
+	auto builder = SPA_POD_BUILDER_INIT(buffer.data(), buffer.size());
+
+	auto cubedVolumes = QVector<float>();
+	for (auto volume: volumes) {
+		cubedVolumes.push_back(volume * volume * volume);
+	}
+
+	// clang-format off
+	auto* pod = spa_pod_builder_add_object(
+			&builder, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
+			SPA_PROP_channelVolumes, SPA_POD_Array(sizeof(float), SPA_TYPE_Float, cubedVolumes.length(), cubedVolumes.data())
+	);
+	// clang-format on
+
+	qCDebug(logNode) << "Changed volumes of" << this->node << "to" << volumes;
+	this->mVolumes = volumes;
+	pw_node_set_param(this->node->proxy(), SPA_PARAM_Props, 0, static_cast<spa_pod*>(pod));
+	emit this->volumesChanged();
+}
+
+} // namespace qs::service::pipewire

src/services/pipewire/node.hpp

@@ -0,0 +1,174 @@
+#pragma once
+
+#include <pipewire/core.h>
+#include <pipewire/node.h>
+#include <pipewire/type.h>
+#include <qcontainerfwd.h>
+#include <qmap.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/param/audio/raw.h>
+#include <spa/pod/pod.h>
+
+#include "core.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwAudioChannel: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum {
+		Unknown = SPA_AUDIO_CHANNEL_UNKNOWN,
+		NA = SPA_AUDIO_CHANNEL_NA,
+		Mono = SPA_AUDIO_CHANNEL_MONO,
+		FrontCenter = SPA_AUDIO_CHANNEL_FC,
+		FrontLeft = SPA_AUDIO_CHANNEL_FL,
+		FrontRight = SPA_AUDIO_CHANNEL_FR,
+		FrontLeftCenter = SPA_AUDIO_CHANNEL_FLC,
+		FrontRightCenter = SPA_AUDIO_CHANNEL_FRC,
+		FrontLeftWide = SPA_AUDIO_CHANNEL_FLW,
+		FrontRightWide = SPA_AUDIO_CHANNEL_FRW,
+		FrontCenterHigh = SPA_AUDIO_CHANNEL_FCH,
+		FrontLeftHigh = SPA_AUDIO_CHANNEL_FLH,
+		FrontRightHigh = SPA_AUDIO_CHANNEL_FRH,
+		LowFrequencyEffects = SPA_AUDIO_CHANNEL_LFE,
+		LowFrequencyEffects2 = SPA_AUDIO_CHANNEL_LFE2,
+		LowFrequencyEffectsLeft = SPA_AUDIO_CHANNEL_LLFE,
+		LowFrequencyEffectsRight = SPA_AUDIO_CHANNEL_RLFE,
+		SideLeft = SPA_AUDIO_CHANNEL_SL,
+		SideRight = SPA_AUDIO_CHANNEL_SR,
+		RearCenter = SPA_AUDIO_CHANNEL_RC,
+		RearLeft = SPA_AUDIO_CHANNEL_RL,
+		RearRight = SPA_AUDIO_CHANNEL_RR,
+		RearLeftCenter = SPA_AUDIO_CHANNEL_RLC,
+		RearRightCenter = SPA_AUDIO_CHANNEL_RRC,
+		TopCenter = SPA_AUDIO_CHANNEL_TC,
+		TopFrontCenter = SPA_AUDIO_CHANNEL_TFC,
+		TopFrontLeft = SPA_AUDIO_CHANNEL_TFL,
+		TopFrontRight = SPA_AUDIO_CHANNEL_TFR,
+		TopFrontLeftCenter = SPA_AUDIO_CHANNEL_TFLC,
+		TopFrontRightCenter = SPA_AUDIO_CHANNEL_TFRC,
+		TopSideLeft = SPA_AUDIO_CHANNEL_TSL,
+		TopSideRight = SPA_AUDIO_CHANNEL_TSR,
+		TopRearCenter = SPA_AUDIO_CHANNEL_TRC,
+		TopRearLeft = SPA_AUDIO_CHANNEL_TRL,
+		TopRearRight = SPA_AUDIO_CHANNEL_TRR,
+		BottomCenter = SPA_AUDIO_CHANNEL_BC,
+		BottomLeftCenter = SPA_AUDIO_CHANNEL_BLC,
+		BottomRightCenter = SPA_AUDIO_CHANNEL_BRC,
+		/// The start of the aux channel range.
+		///
+		/// Values between AuxRangeStart and AuxRangeEnd are valid.
+		AuxRangeStart = SPA_AUDIO_CHANNEL_START_Aux,
+		/// The end of the aux channel range.
+		///
+		/// Values between AuxRangeStart and AuxRangeEnd are valid.
+		AuxRangeEnd = SPA_AUDIO_CHANNEL_LAST_Aux,
+		/// The end of the custom channel range.
+		///
+		/// Values starting at CustomRangeStart are valid.
+		CustomRangeStart = SPA_AUDIO_CHANNEL_START_Custom,
+	};
+	Q_ENUM(Enum);
+
+	/// Print a human readable representation of the given channel,
+	/// including aux and custom channel ranges.
+	Q_INVOKABLE static QString toString(PwAudioChannel::Enum value);
+};
+
+enum class PwNodeType {
+	Untracked,
+	Audio,
+};
+
+class PwNode;
+
+class PwNodeBoundData {
+public:
+	PwNodeBoundData() = default;
+	virtual ~PwNodeBoundData() = default;
+	Q_DISABLE_COPY_MOVE(PwNodeBoundData);
+
+	virtual void onInfo(const pw_node_info* /*info*/) {}
+	virtual void onSpaParam(quint32 /*id*/, quint32 /*index*/, const spa_pod* /*param*/) {}
+	virtual void onUnbind() {}
+};
+
+class PwNodeBoundAudio
+    : public QObject
+    , public PwNodeBoundData {
+	Q_OBJECT;
+
+public:
+	explicit PwNodeBoundAudio(PwNode* node): node(node) {}
+
+	void onInfo(const pw_node_info* info) override;
+	void onSpaParam(quint32 id, quint32 index, const spa_pod* param) override;
+	void onUnbind() override;
+
+	[[nodiscard]] bool isMuted() const;
+	void setMuted(bool muted);
+
+	[[nodiscard]] float averageVolume() const;
+	void setAverageVolume(float volume);
+
+	[[nodiscard]] QVector<PwAudioChannel::Enum> channels() const;
+
+	[[nodiscard]] QVector<float> volumes() const;
+	void setVolumes(const QVector<float>& volumes);
+
+signals:
+	void volumesChanged();
+	void channelsChanged();
+	void mutedChanged();
+
+private:
+	void updateVolumeFromParam(const spa_pod* param);
+	void updateMutedFromParam(const spa_pod* param);
+
+	bool mMuted = false;
+	QVector<PwAudioChannel::Enum> mChannels;
+	QVector<float> mVolumes;
+	PwNode* node;
+};
+
+constexpr const char TYPE_INTERFACE_Node[] = PW_TYPE_INTERFACE_Node;             // NOLINT
+class PwNode: public PwBindable<pw_node, TYPE_INTERFACE_Node, PW_VERSION_NODE> { // NOLINT
+	Q_OBJECT;
+
+public:
+	void bindHooks() override;
+	void unbindHooks() override;
+	void initProps(const spa_dict* props) override;
+
+	QString name;
+	QString description;
+	QString nick;
+	QMap<QString, QString> properties;
+
+	PwNodeType type = PwNodeType::Untracked;
+	bool isSink = false;
+	bool isStream = false;
+
+	PwNodeBoundData* boundData = nullptr;
+
+signals:
+	void propertiesChanged();
+
+private:
+	static const pw_node_events EVENTS;
+	static void onInfo(void* data, const pw_node_info* info);
+	static void
+	onParam(void* data, qint32 seq, quint32 id, quint32 index, quint32 next, const spa_pod* param);
+
+	SpaHook listener;
+};
+
+} // namespace qs::service::pipewire

src/services/pipewire/qml.cpp

@@ -0,0 +1,472 @@
+#include "qml.hpp"
+
+#include <qcontainerfwd.h>
+#include <qlist.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "connection.hpp"
+#include "link.hpp"
+#include "metadata.hpp"
+#include "node.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+void PwObjectIface::ref() {
+	this->refcount++;
+
+	if (this->refcount == 1) {
+		this->object->ref();
+	}
+}
+
+void PwObjectIface::unref() {
+	if (this->refcount == 0) return;
+	this->refcount--;
+
+	if (this->refcount == 0) {
+		this->object->unref();
+	}
+}
+
+Pipewire::Pipewire(QObject* parent): QObject(parent) {
+	auto* connection = PwConnection::instance();
+
+	for (auto* node: connection->registry.nodes.values()) {
+		this->onNodeAdded(node);
+	}
+
+	QObject::connect(&connection->registry, &PwRegistry::nodeAdded, this, &Pipewire::onNodeAdded);
+
+	for (auto* link: connection->registry.links.values()) {
+		this->onLinkAdded(link);
+	}
+
+	QObject::connect(&connection->registry, &PwRegistry::linkAdded, this, &Pipewire::onLinkAdded);
+
+	for (auto* group: connection->registry.linkGroups) {
+		this->onLinkGroupAdded(group);
+	}
+
+	QObject::connect(
+	    &connection->registry,
+	    &PwRegistry::linkGroupAdded,
+	    this,
+	    &Pipewire::onLinkGroupAdded
+	);
+
+	// clang-format off
+	QObject::connect(&connection->defaults, &PwDefaultsMetadata::defaultSinkChanged, this, &Pipewire::defaultAudioSinkChanged);
+	QObject::connect(&connection->defaults, &PwDefaultsMetadata::defaultSourceChanged, this, &Pipewire::defaultAudioSourceChanged);
+	// clang-format on
+}
+
+QQmlListProperty<PwNodeIface> Pipewire::nodes() {
+	return QQmlListProperty<PwNodeIface>(this, nullptr, &Pipewire::nodesCount, &Pipewire::nodeAt);
+}
+
+qsizetype Pipewire::nodesCount(QQmlListProperty<PwNodeIface>* property) {
+	return static_cast<Pipewire*>(property->object)->mNodes.count(); // NOLINT
+}
+
+PwNodeIface* Pipewire::nodeAt(QQmlListProperty<PwNodeIface>* property, qsizetype index) {
+	return static_cast<Pipewire*>(property->object)->mNodes.at(index); // NOLINT
+}
+
+void Pipewire::onNodeAdded(PwNode* node) {
+	auto* iface = PwNodeIface::instance(node);
+	QObject::connect(iface, &QObject::destroyed, this, &Pipewire::onNodeRemoved);
+
+	this->mNodes.push_back(iface);
+	emit this->nodesChanged();
+}
+
+void Pipewire::onNodeRemoved(QObject* object) {
+	auto* iface = static_cast<PwNodeIface*>(object); // NOLINT
+	this->mNodes.removeOne(iface);
+	emit this->nodesChanged();
+}
+
+QQmlListProperty<PwLinkIface> Pipewire::links() {
+	return QQmlListProperty<PwLinkIface>(this, nullptr, &Pipewire::linksCount, &Pipewire::linkAt);
+}
+
+qsizetype Pipewire::linksCount(QQmlListProperty<PwLinkIface>* property) {
+	return static_cast<Pipewire*>(property->object)->mLinks.count(); // NOLINT
+}
+
+PwLinkIface* Pipewire::linkAt(QQmlListProperty<PwLinkIface>* property, qsizetype index) {
+	return static_cast<Pipewire*>(property->object)->mLinks.at(index); // NOLINT
+}
+
+void Pipewire::onLinkAdded(PwLink* link) {
+	auto* iface = PwLinkIface::instance(link);
+	QObject::connect(iface, &QObject::destroyed, this, &Pipewire::onLinkRemoved);
+
+	this->mLinks.push_back(iface);
+	emit this->linksChanged();
+}
+
+void Pipewire::onLinkRemoved(QObject* object) {
+	auto* iface = static_cast<PwLinkIface*>(object); // NOLINT
+	this->mLinks.removeOne(iface);
+	emit this->linksChanged();
+}
+
+QQmlListProperty<PwLinkGroupIface> Pipewire::linkGroups() {
+	return QQmlListProperty<PwLinkGroupIface>(
+	    this,
+	    nullptr,
+	    &Pipewire::linkGroupsCount,
+	    &Pipewire::linkGroupAt
+	);
+}
+
+qsizetype Pipewire::linkGroupsCount(QQmlListProperty<PwLinkGroupIface>* property) {
+	return static_cast<Pipewire*>(property->object)->mLinkGroups.count(); // NOLINT
+}
+
+PwLinkGroupIface*
+Pipewire::linkGroupAt(QQmlListProperty<PwLinkGroupIface>* property, qsizetype index) {
+	return static_cast<Pipewire*>(property->object)->mLinkGroups.at(index); // NOLINT
+}
+
+void Pipewire::onLinkGroupAdded(PwLinkGroup* linkGroup) {
+	auto* iface = PwLinkGroupIface::instance(linkGroup);
+	QObject::connect(iface, &QObject::destroyed, this, &Pipewire::onLinkGroupRemoved);
+
+	this->mLinkGroups.push_back(iface);
+	emit this->linkGroupsChanged();
+}
+
+void Pipewire::onLinkGroupRemoved(QObject* object) {
+	auto* iface = static_cast<PwLinkGroupIface*>(object); // NOLINT
+	this->mLinkGroups.removeOne(iface);
+	emit this->linkGroupsChanged();
+}
+
+PwNodeIface* Pipewire::defaultAudioSink() const { // NOLINT
+	auto* connection = PwConnection::instance();
+	auto name = connection->defaults.defaultSink();
+
+	for (auto* node: connection->registry.nodes.values()) {
+		if (name == node->name) {
+			return PwNodeIface::instance(node);
+		}
+	}
+
+	return nullptr;
+}
+
+PwNodeIface* Pipewire::defaultAudioSource() const { // NOLINT
+	auto* connection = PwConnection::instance();
+	auto name = connection->defaults.defaultSource();
+
+	for (auto* node: connection->registry.nodes.values()) {
+		if (name == node->name) {
+			return PwNodeIface::instance(node);
+		}
+	}
+
+	return nullptr;
+}
+
+PwNodeIface* PwNodeLinkTracker::node() const { return this->mNode; }
+
+void PwNodeLinkTracker::setNode(PwNodeIface* node) {
+	if (node == this->mNode) return;
+
+	if (this->mNode != nullptr) {
+		if (node == nullptr) {
+			QObject::disconnect(&PwConnection::instance()->registry, nullptr, this, nullptr);
+		}
+
+		QObject::disconnect(this->mNode, nullptr, this, nullptr);
+	}
+
+	if (node != nullptr) {
+		if (this->mNode == nullptr) {
+			QObject::connect(
+			    &PwConnection::instance()->registry,
+			    &PwRegistry::linkGroupAdded,
+			    this,
+			    &PwNodeLinkTracker::onLinkGroupCreated
+			);
+		}
+
+		QObject::connect(node, &QObject::destroyed, this, &PwNodeLinkTracker::onNodeDestroyed);
+	}
+
+	this->mNode = node;
+	this->updateLinks();
+	emit this->nodeChanged();
+}
+
+void PwNodeLinkTracker::updateLinks() {
+	// done first to avoid unref->reref of nodes
+	auto newLinks = QVector<PwLinkGroupIface*>();
+	if (this->mNode != nullptr) {
+		auto* connection = PwConnection::instance();
+
+		for (auto* link: connection->registry.linkGroups) {
+			if ((!this->mNode->isSink() && link->outputNode() == this->mNode->id())
+			    || (this->mNode->isSink() && link->inputNode() == this->mNode->id()))
+			{
+				auto* iface = PwLinkGroupIface::instance(link);
+
+				// do not connect twice
+				if (!this->mLinkGroups.contains(iface)) {
+					QObject::connect(
+					    iface,
+					    &QObject::destroyed,
+					    this,
+					    &PwNodeLinkTracker::onLinkGroupDestroyed
+					);
+				}
+
+				newLinks.push_back(iface);
+			}
+		}
+	}
+
+	for (auto* iface: this->mLinkGroups) {
+		// only disconnect no longer used nodes
+		if (!newLinks.contains(iface)) {
+			QObject::disconnect(iface, nullptr, this, nullptr);
+		}
+	}
+
+	this->mLinkGroups = newLinks;
+	emit this->linkGroupsChanged();
+}
+
+QQmlListProperty<PwLinkGroupIface> PwNodeLinkTracker::linkGroups() {
+	return QQmlListProperty<PwLinkGroupIface>(
+	    this,
+	    nullptr,
+	    &PwNodeLinkTracker::linkGroupsCount,
+	    &PwNodeLinkTracker::linkGroupAt
+	);
+}
+
+qsizetype PwNodeLinkTracker::linkGroupsCount(QQmlListProperty<PwLinkGroupIface>* property) {
+	return static_cast<PwNodeLinkTracker*>(property->object)->mLinkGroups.count(); // NOLINT
+}
+
+PwLinkGroupIface*
+PwNodeLinkTracker::linkGroupAt(QQmlListProperty<PwLinkGroupIface>* property, qsizetype index) {
+	return static_cast<PwNodeLinkTracker*>(property->object)->mLinkGroups.at(index); // NOLINT
+}
+
+void PwNodeLinkTracker::onNodeDestroyed() {
+	this->mNode = nullptr;
+	this->updateLinks();
+	emit this->nodeChanged();
+}
+
+void PwNodeLinkTracker::onLinkGroupCreated(PwLinkGroup* linkGroup) {
+	if ((!this->mNode->isSink() && linkGroup->outputNode() == this->mNode->id())
+	    || (this->mNode->isSink() && linkGroup->inputNode() == this->mNode->id()))
+	{
+		auto* iface = PwLinkGroupIface::instance(linkGroup);
+		QObject::connect(iface, &QObject::destroyed, this, &PwNodeLinkTracker::onLinkGroupDestroyed);
+		this->mLinkGroups.push_back(iface);
+		emit this->linkGroupsChanged();
+	}
+}
+
+void PwNodeLinkTracker::onLinkGroupDestroyed(QObject* object) {
+	if (this->mLinkGroups.removeOne(object)) {
+		emit this->linkGroupsChanged();
+	}
+}
+
+PwNodeAudioIface::PwNodeAudioIface(PwNodeBoundAudio* boundData, QObject* parent)
+    : QObject(parent)
+    , boundData(boundData) {
+	// clang-format off
+	QObject::connect(boundData, &PwNodeBoundAudio::mutedChanged, this, &PwNodeAudioIface::mutedChanged);
+	QObject::connect(boundData, &PwNodeBoundAudio::channelsChanged, this, &PwNodeAudioIface::channelsChanged);
+	QObject::connect(boundData, &PwNodeBoundAudio::volumesChanged, this, &PwNodeAudioIface::volumesChanged);
+	// clang-format on
+}
+
+bool PwNodeAudioIface::isMuted() const { return this->boundData->isMuted(); }
+
+void PwNodeAudioIface::setMuted(bool muted) { this->boundData->setMuted(muted); }
+
+float PwNodeAudioIface::averageVolume() const { return this->boundData->averageVolume(); }
+
+void PwNodeAudioIface::setAverageVolume(float volume) { this->boundData->setAverageVolume(volume); }
+
+QVector<PwAudioChannel::Enum> PwNodeAudioIface::channels() const {
+	return this->boundData->channels();
+}
+
+QVector<float> PwNodeAudioIface::volumes() const { return this->boundData->volumes(); }
+
+void PwNodeAudioIface::setVolumes(const QVector<float>& volumes) {
+	this->boundData->setVolumes(volumes);
+}
+
+PwNodeIface::PwNodeIface(PwNode* node): PwObjectIface(node), mNode(node) {
+	QObject::connect(node, &PwNode::propertiesChanged, this, &PwNodeIface::propertiesChanged);
+
+	if (auto* audioBoundData = dynamic_cast<PwNodeBoundAudio*>(node->boundData)) {
+		this->audioIface = new PwNodeAudioIface(audioBoundData, this);
+	}
+}
+
+PwNode* PwNodeIface::node() const { return this->mNode; }
+
+QString PwNodeIface::name() const { return this->mNode->name; }
+
+quint32 PwNodeIface::id() const { return this->mNode->id; }
+
+QString PwNodeIface::description() const { return this->mNode->description; }
+
+QString PwNodeIface::nickname() const { return this->mNode->nick; }
+
+bool PwNodeIface::isSink() const { return this->mNode->isSink; }
+
+bool PwNodeIface::isStream() const { return this->mNode->isStream; }
+
+QVariantMap PwNodeIface::properties() const {
+	auto map = QVariantMap();
+	for (auto [k, v]: this->mNode->properties.asKeyValueRange()) {
+		map.insert(k, QVariant::fromValue(v));
+	}
+
+	return map;
+}
+
+PwNodeAudioIface* PwNodeIface::audio() const { return this->audioIface; }
+
+PwNodeIface* PwNodeIface::instance(PwNode* node) {
+	auto v = node->property("iface");
+	if (v.canConvert<PwNodeIface*>()) {
+		return v.value<PwNodeIface*>();
+	}
+
+	auto* instance = new PwNodeIface(node);
+	node->setProperty("iface", QVariant::fromValue(instance));
+
+	return instance;
+}
+
+PwLinkIface::PwLinkIface(PwLink* link): PwObjectIface(link), mLink(link) {
+	QObject::connect(link, &PwLink::stateChanged, this, &PwLinkIface::stateChanged);
+}
+
+PwLink* PwLinkIface::link() const { return this->mLink; }
+
+quint32 PwLinkIface::id() const { return this->mLink->id; }
+
+PwNodeIface* PwLinkIface::target() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mLink->inputNode())
+	);
+}
+
+PwNodeIface* PwLinkIface::source() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mLink->outputNode())
+	);
+}
+
+PwLinkState::Enum PwLinkIface::state() const { return this->mLink->state(); }
+
+PwLinkIface* PwLinkIface::instance(PwLink* link) {
+	auto v = link->property("iface");
+	if (v.canConvert<PwLinkIface*>()) {
+		return v.value<PwLinkIface*>();
+	}
+
+	auto* instance = new PwLinkIface(link);
+	link->setProperty("iface", QVariant::fromValue(instance));
+
+	return instance;
+}
+
+PwLinkGroupIface::PwLinkGroupIface(PwLinkGroup* group): QObject(group), mGroup(group) {
+	QObject::connect(group, &PwLinkGroup::stateChanged, this, &PwLinkGroupIface::stateChanged);
+	QObject::connect(group, &QObject::destroyed, this, [this]() { delete this; });
+}
+
+void PwLinkGroupIface::ref() { this->mGroup->ref(); }
+
+void PwLinkGroupIface::unref() { this->mGroup->unref(); }
+
+PwLinkGroup* PwLinkGroupIface::group() const { return this->mGroup; }
+
+PwNodeIface* PwLinkGroupIface::target() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mGroup->inputNode())
+	);
+}
+
+PwNodeIface* PwLinkGroupIface::source() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mGroup->outputNode())
+	);
+}
+
+PwLinkState::Enum PwLinkGroupIface::state() const { return this->mGroup->state(); }
+
+PwLinkGroupIface* PwLinkGroupIface::instance(PwLinkGroup* group) {
+	auto v = group->property("iface");
+	if (v.canConvert<PwLinkGroupIface*>()) {
+		return v.value<PwLinkGroupIface*>();
+	}
+
+	auto* instance = new PwLinkGroupIface(group);
+	group->setProperty("iface", QVariant::fromValue(instance));
+
+	return instance;
+}
+
+PwObjectTracker::~PwObjectTracker() { this->clearList(); }
+
+QList<QObject*> PwObjectTracker::objects() const { return this->trackedObjects; }
+
+void PwObjectTracker::setObjects(const QList<QObject*>& objects) {
+	// +1 ref before removing old refs to avoid an unbind->bind.
+	for (auto* object: objects) {
+		if (auto* pwObject = dynamic_cast<PwObjectRefIface*>(object)) {
+			pwObject->ref();
+		}
+	}
+
+	this->clearList();
+
+	// connect destroy
+	for (auto* object: objects) {
+		if (auto* pwObject = dynamic_cast<PwObjectRefIface*>(object)) {
+			QObject::connect(object, &QObject::destroyed, this, &PwObjectTracker::objectDestroyed);
+		}
+	}
+
+	this->trackedObjects = objects;
+}
+
+void PwObjectTracker::clearList() {
+	for (auto* object: this->trackedObjects) {
+		if (auto* pwObject = dynamic_cast<PwObjectRefIface*>(object)) {
+			pwObject->unref();
+			QObject::disconnect(object, nullptr, this, nullptr);
+		}
+	}
+
+	this->trackedObjects.clear();
+}
+
+void PwObjectTracker::objectDestroyed(QObject* object) {
+	this->trackedObjects.removeOne(object);
+	emit this->objectsChanged();
+}
+
+} // namespace qs::service::pipewire

src/services/pipewire/qml.hpp

@@ -0,0 +1,368 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "link.hpp"
+#include "node.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwNodeIface;
+class PwLinkIface;
+class PwLinkGroupIface;
+
+class PwObjectRefIface {
+public:
+	PwObjectRefIface() = default;
+	virtual ~PwObjectRefIface() = default;
+	Q_DISABLE_COPY_MOVE(PwObjectRefIface);
+
+	virtual void ref() = 0;
+	virtual void unref() = 0;
+};
+
+class PwObjectIface
+    : public QObject
+    , public PwObjectRefIface {
+	Q_OBJECT;
+
+public:
+	explicit PwObjectIface(PwBindableObject* object): QObject(object), object(object) {};
+	// destructor should ONLY be called by the pw object destructor, making an unref unnecessary
+	~PwObjectIface() override = default;
+	Q_DISABLE_COPY_MOVE(PwObjectIface);
+
+	void ref() override;
+	void unref() override;
+
+private:
+	quint32 refcount = 0;
+	PwBindableObject* object;
+};
+
+///! Contains links to all pipewire objects.
+class Pipewire: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// All pipewire nodes.
+	Q_PROPERTY(QQmlListProperty<PwNodeIface> nodes READ nodes NOTIFY nodesChanged);
+	/// All pipewire links.
+	Q_PROPERTY(QQmlListProperty<PwLinkIface> links READ links NOTIFY linksChanged);
+	/// All pipewire link groups.
+	Q_PROPERTY(QQmlListProperty<PwLinkGroupIface> linkGroups READ linkGroups NOTIFY linkGroupsChanged);
+	/// The default audio sink or `null`.
+	Q_PROPERTY(PwNodeIface* defaultAudioSink READ defaultAudioSink NOTIFY defaultAudioSinkChanged);
+	/// The default audio source or `null`.
+	Q_PROPERTY(PwNodeIface* defaultAudioSource READ defaultAudioSource NOTIFY defaultAudioSourceChanged);
+	// clang-format on
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	explicit Pipewire(QObject* parent = nullptr);
+
+	[[nodiscard]] QQmlListProperty<PwNodeIface> nodes();
+	[[nodiscard]] QQmlListProperty<PwLinkIface> links();
+	[[nodiscard]] QQmlListProperty<PwLinkGroupIface> linkGroups();
+	[[nodiscard]] PwNodeIface* defaultAudioSink() const;
+	[[nodiscard]] PwNodeIface* defaultAudioSource() const;
+
+signals:
+	void nodesChanged();
+	void linksChanged();
+	void linkGroupsChanged();
+	void defaultAudioSinkChanged();
+	void defaultAudioSourceChanged();
+
+private slots:
+	void onNodeAdded(PwNode* node);
+	void onNodeRemoved(QObject* object);
+	void onLinkAdded(PwLink* link);
+	void onLinkRemoved(QObject* object);
+	void onLinkGroupAdded(PwLinkGroup* group);
+	void onLinkGroupRemoved(QObject* object);
+
+private:
+	static qsizetype nodesCount(QQmlListProperty<PwNodeIface>* property);
+	static PwNodeIface* nodeAt(QQmlListProperty<PwNodeIface>* property, qsizetype index);
+	static qsizetype linksCount(QQmlListProperty<PwLinkIface>* property);
+	static PwLinkIface* linkAt(QQmlListProperty<PwLinkIface>* property, qsizetype index);
+	static qsizetype linkGroupsCount(QQmlListProperty<PwLinkGroupIface>* property);
+	static PwLinkGroupIface*
+	linkGroupAt(QQmlListProperty<PwLinkGroupIface>* property, qsizetype index);
+
+	QVector<PwNodeIface*> mNodes;
+	QVector<PwLinkIface*> mLinks;
+	QVector<PwLinkGroupIface*> mLinkGroups;
+};
+
+///! Tracks all link connections to a given node.
+class PwNodeLinkTracker: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// The node to track connections to.
+	Q_PROPERTY(PwNodeIface* node READ node WRITE setNode NOTIFY nodeChanged);
+	/// Link groups connected to the given node.
+	///
+	/// If the node is a sink, links which target the node will be tracked.
+	/// If the node is a source, links which source the node will be tracked.
+	Q_PROPERTY(QQmlListProperty<PwLinkGroupIface> linkGroups READ linkGroups NOTIFY linkGroupsChanged);
+	// clang-format on
+	QML_ELEMENT;
+
+public:
+	explicit PwNodeLinkTracker(QObject* parent = nullptr): QObject(parent) {}
+
+	[[nodiscard]] PwNodeIface* node() const;
+	void setNode(PwNodeIface* node);
+
+	[[nodiscard]] QQmlListProperty<PwLinkGroupIface> linkGroups();
+
+signals:
+	void nodeChanged();
+	void linkGroupsChanged();
+
+private slots:
+	void onNodeDestroyed();
+	void onLinkGroupCreated(PwLinkGroup* linkGroup);
+	void onLinkGroupDestroyed(QObject* object);
+
+private:
+	static qsizetype linkGroupsCount(QQmlListProperty<PwLinkGroupIface>* property);
+	static PwLinkGroupIface*
+	linkGroupAt(QQmlListProperty<PwLinkGroupIface>* property, qsizetype index);
+
+	void updateLinks();
+
+	PwNodeIface* mNode = nullptr;
+	QVector<PwLinkGroupIface*> mLinkGroups;
+};
+
+///! Audio specific properties of pipewire nodes.
+class PwNodeAudioIface: public QObject {
+	Q_OBJECT;
+	/// If the node is currently muted. Setting this property changes the mute state.
+	///
+	/// **This property is invalid unless the node is [bound](../pwobjecttracker).**
+	Q_PROPERTY(bool muted READ isMuted WRITE setMuted NOTIFY mutedChanged);
+	/// The average volume over all channels of the node.
+	/// Setting this property modifies the volume of all channels proportionately.
+	///
+	/// **This property is invalid unless the node is [bound](../pwobjecttracker).**
+	Q_PROPERTY(float volume READ averageVolume WRITE setAverageVolume NOTIFY volumesChanged);
+	/// The audio channels present on the node.
+	///
+	/// **This property is invalid unless the node is [bound](../pwobjecttracker).**
+	Q_PROPERTY(QVector<PwAudioChannel::Enum> channels READ channels NOTIFY channelsChanged);
+	/// The volumes of each audio channel individually. Each entry corrosponds to
+	/// the channel at the same index in `channels`. `volumes` and `channels` will always be
+	/// the same length.
+	///
+	/// **This property is invalid unless the node is [bound](../pwobjecttracker).**
+	Q_PROPERTY(QVector<float> volumes READ volumes WRITE setVolumes NOTIFY volumesChanged);
+	QML_NAMED_ELEMENT(PwNodeAudio);
+	QML_UNCREATABLE("PwNodeAudio cannot be created directly");
+
+public:
+	explicit PwNodeAudioIface(PwNodeBoundAudio* boundData, QObject* parent);
+
+	[[nodiscard]] bool isMuted() const;
+	void setMuted(bool muted);
+
+	[[nodiscard]] float averageVolume() const;
+	void setAverageVolume(float volume);
+
+	[[nodiscard]] QVector<PwAudioChannel::Enum> channels() const;
+
+	[[nodiscard]] QVector<float> volumes() const;
+	void setVolumes(const QVector<float>& volumes);
+
+signals:
+	void mutedChanged();
+	void channelsChanged();
+	void volumesChanged();
+
+private:
+	PwNodeBoundAudio* boundData;
+};
+
+///! A node in the pipewire connection graph.
+class PwNodeIface: public PwObjectIface {
+	Q_OBJECT;
+	/// The pipewire object id of the node.
+	///
+	/// Mainly useful for debugging. you can inspect the node directly
+	/// with `pw-cli i <id>`.
+	Q_PROPERTY(quint32 id READ id CONSTANT);
+	/// The node's name, corrosponding to the object's `node.name` property.
+	Q_PROPERTY(QString name READ name CONSTANT);
+	/// The node's description, corrosponding to the object's `node.description` property.
+	///
+	/// May be empty. Generally more human readable than `name`.
+	Q_PROPERTY(QString description READ description CONSTANT);
+	/// The node's nickname, corrosponding to the object's `node.nickname` property.
+	///
+	/// May be empty. Generally but not always more human readable than `description`.
+	Q_PROPERTY(QString nickname READ nickname CONSTANT);
+	/// If `true`, then the node accepts audio input from other nodes,
+	/// if `false` the node outputs audio to other nodes.
+	Q_PROPERTY(bool isSink READ isSink CONSTANT);
+	/// If `true` then the node is likely to be a program, if false it is liekly to be hardware.
+	Q_PROPERTY(bool isStream READ isStream CONSTANT);
+	/// The property set present on the node, as an object containing key-value pairs.
+	/// You can inspect this directly with `pw-cli i <id>`.
+	///
+	/// A few properties of note, which may or may not be present:
+	/// - `application.name` - A suggested human readable name for the node.
+	/// - `application.icon-name` - The name of an icon recommended to display for the node.
+	/// - `media.name` - A description of the currently playing media.
+	///   (more likely to be present than `media.title` and `media.artist`)
+	/// - `media.title` - The title of the currently playing media.
+	/// - `media.artist` - The artist of the currently playing media.
+	///
+	/// **This property is invalid unless the node is [bound](../pwobjecttracker).**
+	Q_PROPERTY(QVariantMap properties READ properties NOTIFY propertiesChanged);
+	/// Extra information present only if the node sends or receives audio.
+	Q_PROPERTY(PwNodeAudioIface* audio READ audio CONSTANT);
+	QML_NAMED_ELEMENT(PwNode);
+	QML_UNCREATABLE("PwNodes cannot be created directly");
+
+public:
+	explicit PwNodeIface(PwNode* node);
+
+	[[nodiscard]] PwNode* node() const;
+	[[nodiscard]] quint32 id() const;
+	[[nodiscard]] QString name() const;
+	[[nodiscard]] QString description() const;
+	[[nodiscard]] QString nickname() const;
+	[[nodiscard]] bool isSink() const;
+	[[nodiscard]] bool isStream() const;
+	[[nodiscard]] QVariantMap properties() const;
+	[[nodiscard]] PwNodeAudioIface* audio() const;
+
+	static PwNodeIface* instance(PwNode* node);
+
+signals:
+	void propertiesChanged();
+
+private:
+	PwNode* mNode;
+	PwNodeAudioIface* audioIface = nullptr;
+};
+
+///! A connection between pipewire nodes.
+/// Note that there is one link per *channel* of a connection between nodes.
+/// You usually want [PwLinkGroup](../pwlinkgroup).
+class PwLinkIface: public PwObjectIface {
+	Q_OBJECT;
+	/// The pipewire object id of the link.
+	///
+	/// Mainly useful for debugging. you can inspect the link directly
+	/// with `pw-cli i <id>`.
+	Q_PROPERTY(quint32 id READ id CONSTANT);
+	/// The node that is *receiving* information. (the sink)
+	Q_PROPERTY(PwNodeIface* target READ target CONSTANT);
+	/// The node that is *sending* information. (the source)
+	Q_PROPERTY(PwNodeIface* source READ source CONSTANT);
+	/// The current state of the link.
+	///
+	/// **This property is invalid unless the link is [bound](../pwobjecttracker).**
+	Q_PROPERTY(PwLinkState::Enum state READ state NOTIFY stateChanged);
+	QML_NAMED_ELEMENT(PwLink);
+	QML_UNCREATABLE("PwLinks cannot be created directly");
+
+public:
+	explicit PwLinkIface(PwLink* link);
+
+	[[nodiscard]] PwLink* link() const;
+	[[nodiscard]] quint32 id() const;
+	[[nodiscard]] PwNodeIface* target() const;
+	[[nodiscard]] PwNodeIface* source() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+	static PwLinkIface* instance(PwLink* link);
+
+signals:
+	void stateChanged();
+
+private:
+	PwLink* mLink;
+};
+
+///! A group of connections between pipewire nodes.
+/// A group of connections between pipewire nodes, one per source->target pair.
+class PwLinkGroupIface
+    : public QObject
+    , public PwObjectRefIface {
+	Q_OBJECT;
+	/// The node that is *receiving* information. (the sink)
+	Q_PROPERTY(PwNodeIface* target READ target CONSTANT);
+	/// The node that is *sending* information. (the source)
+	Q_PROPERTY(PwNodeIface* source READ source CONSTANT);
+	/// The current state of the link group.
+	///
+	/// **This property is invalid unless the link is [bound](../pwobjecttracker).**
+	Q_PROPERTY(PwLinkState::Enum state READ state NOTIFY stateChanged);
+	QML_NAMED_ELEMENT(PwLinkGroup);
+	QML_UNCREATABLE("PwLinkGroups cannot be created directly");
+
+public:
+	explicit PwLinkGroupIface(PwLinkGroup* group);
+	// destructor should ONLY be called by the pw object destructor, making an unref unnecessary
+	~PwLinkGroupIface() override = default;
+	Q_DISABLE_COPY_MOVE(PwLinkGroupIface);
+
+	void ref() override;
+	void unref() override;
+
+	[[nodiscard]] PwLinkGroup* group() const;
+	[[nodiscard]] PwNodeIface* target() const;
+	[[nodiscard]] PwNodeIface* source() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+	static PwLinkGroupIface* instance(PwLinkGroup* group);
+
+signals:
+	void stateChanged();
+
+private:
+	PwLinkGroup* mGroup;
+};
+
+///! Binds pipewire objects.
+/// If the object list of at least one PwObjectTracker contains a given pipewire object,
+/// it will become *bound* and you will be able to interact with bound-only properties.
+class PwObjectTracker: public QObject {
+	Q_OBJECT;
+	/// The list of objects to bind.
+	Q_PROPERTY(QList<QObject*> objects READ objects WRITE setObjects NOTIFY objectsChanged);
+	QML_ELEMENT;
+
+public:
+	explicit PwObjectTracker(QObject* parent = nullptr): QObject(parent) {}
+	~PwObjectTracker() override;
+	Q_DISABLE_COPY_MOVE(PwObjectTracker);
+
+	[[nodiscard]] QList<QObject*> objects() const;
+	void setObjects(const QList<QObject*>& objects);
+
+signals:
+	void objectsChanged();
+
+private slots:
+	void objectDestroyed(QObject* object);
+
+private:
+	void clearList();
+
+	QList<QObject*> trackedObjects;
+};
+
+} // namespace qs::service::pipewire

src/services/pipewire/registry.cpp

@@ -0,0 +1,193 @@
+#include "registry.hpp"
+#include <cstring>
+
+#include <pipewire/core.h>
+#include <pipewire/extensions/metadata.h>
+#include <pipewire/link.h>
+#include <pipewire/node.h>
+#include <pipewire/proxy.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "core.hpp"
+#include "link.hpp"
+#include "metadata.hpp"
+#include "node.hpp"
+
+namespace qs::service::pipewire {
+
+Q_LOGGING_CATEGORY(logRegistry, "quickshell.service.pipewire.registry", QtWarningMsg);
+
+PwBindableObject::~PwBindableObject() {
+	if (this->id != 0) {
+		qCFatal(logRegistry) << "Destroyed pipewire object" << this
+		                     << "without causing safeDestroy. THIS IS UNDEFINED BEHAVIOR.";
+	}
+}
+
+void PwBindableObject::init(PwRegistry* registry, quint32 id, quint32 perms) {
+	this->id = id;
+	this->perms = perms;
+	this->registry = registry;
+	this->setParent(registry);
+	qCDebug(logRegistry) << "Creating object" << this;
+}
+
+void PwBindableObject::safeDestroy() {
+	this->unbind();
+	qCDebug(logRegistry) << "Destroying object" << this;
+	emit this->destroying(this);
+	this->id = 0;
+	delete this;
+}
+
+void PwBindableObject::debugId(QDebug& debug) const {
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace() << this->id << "/" << (this->object == nullptr ? "unbound" : "bound");
+}
+
+void PwBindableObject::ref() {
+	this->refcount++;
+	if (this->refcount == 1) this->bind();
+}
+
+void PwBindableObject::unref() {
+	this->refcount--;
+	if (this->refcount == 0) this->unbind();
+}
+
+void PwBindableObject::bind() {
+	qCDebug(logRegistry) << "Bound object" << this;
+	this->bindHooks();
+}
+
+void PwBindableObject::unbind() {
+	if (this->object == nullptr) return;
+	qCDebug(logRegistry) << "Unbinding object" << this;
+	this->unbindHooks();
+	pw_proxy_destroy(this->object);
+	this->object = nullptr;
+}
+
+QDebug operator<<(QDebug debug, const PwBindableObject* object) {
+	if (object == nullptr) {
+		debug << "PwBindableObject(0x0)";
+	} else {
+		auto saver = QDebugStateSaver(debug);
+		// 0 if not present, start of class name if present
+		auto idx = QString(object->metaObject()->className()).lastIndexOf(':') + 1;
+		debug.nospace() << (object->metaObject()->className() + idx) << '(' // NOLINT
+		                << static_cast<const void*>(object) << ", id=";
+		object->debugId(debug);
+		debug << ')';
+	}
+
+	return debug;
+}
+
+PwBindableObjectRef::PwBindableObjectRef(PwBindableObject* object) { this->setObject(object); }
+
+PwBindableObjectRef::~PwBindableObjectRef() { this->setObject(nullptr); }
+
+void PwBindableObjectRef::setObject(PwBindableObject* object) {
+	if (this->mObject != nullptr) {
+		this->mObject->unref();
+		QObject::disconnect(this->mObject, nullptr, this, nullptr);
+	}
+
+	this->mObject = object;
+
+	if (object != nullptr) {
+		this->mObject->ref();
+		QObject::connect(object, &QObject::destroyed, this, &PwBindableObjectRef::onObjectDestroyed);
+	}
+}
+
+void PwBindableObjectRef::onObjectDestroyed() {
+	// allow references to it so consumers can disconnect themselves
+	emit this->objectDestroyed();
+	this->mObject = nullptr;
+}
+
+void PwRegistry::init(PwCore& core) {
+	this->object = pw_core_get_registry(core.core, PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(this->object, &this->listener.hook, &PwRegistry::EVENTS, this);
+}
+
+const pw_registry_events PwRegistry::EVENTS = {
+    .version = PW_VERSION_REGISTRY_EVENTS,
+    .global = &PwRegistry::onGlobal,
+    .global_remove = &PwRegistry::onGlobalRemoved,
+};
+
+void PwRegistry::onGlobal(
+    void* data,
+    quint32 id,
+    quint32 permissions,
+    const char* type,
+    quint32 /*version*/,
+    const spa_dict* props
+) {
+	auto* self = static_cast<PwRegistry*>(data);
+
+	if (strcmp(type, PW_TYPE_INTERFACE_Metadata) == 0) {
+		auto* meta = new PwMetadata();
+		meta->init(self, id, permissions);
+		meta->initProps(props);
+
+		self->metadata.emplace(id, meta);
+		meta->bind();
+	} else if (strcmp(type, PW_TYPE_INTERFACE_Link) == 0) {
+		auto* link = new PwLink();
+		link->init(self, id, permissions);
+		link->initProps(props);
+
+		self->links.emplace(id, link);
+		self->addLinkToGroup(link);
+		emit self->linkAdded(link);
+	} else if (strcmp(type, PW_TYPE_INTERFACE_Node) == 0) {
+		auto* node = new PwNode();
+		node->init(self, id, permissions);
+		node->initProps(props);
+
+		self->nodes.emplace(id, node);
+		emit self->nodeAdded(node);
+	}
+}
+
+void PwRegistry::onGlobalRemoved(void* data, quint32 id) {
+	auto* self = static_cast<PwRegistry*>(data);
+
+	if (auto* meta = self->metadata.value(id)) {
+		self->metadata.remove(id);
+		meta->safeDestroy();
+	} else if (auto* link = self->links.value(id)) {
+		self->links.remove(id);
+		link->safeDestroy();
+	} else if (auto* node = self->nodes.value(id)) {
+		self->nodes.remove(id);
+		node->safeDestroy();
+	}
+}
+
+void PwRegistry::addLinkToGroup(PwLink* link) {
+	for (auto* group: this->linkGroups) {
+		if (group->tryAddLink(link)) return;
+	}
+
+	auto* group = new PwLinkGroup(link);
+	QObject::connect(group, &QObject::destroyed, this, &PwRegistry::onLinkGroupDestroyed);
+	this->linkGroups.push_back(group);
+	emit this->linkGroupAdded(group);
+}
+
+void PwRegistry::onLinkGroupDestroyed(QObject* object) {
+	auto* group = static_cast<PwLinkGroup*>(object); // NOLINT
+	this->linkGroups.removeOne(group);
+}
+
+} // namespace qs::service::pipewire

src/services/pipewire/registry.hpp

@@ -0,0 +1,160 @@
+#pragma once
+
+#include <pipewire/core.h>
+#include <pipewire/proxy.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qhash.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "core.hpp"
+
+namespace qs::service::pipewire {
+
+Q_DECLARE_LOGGING_CATEGORY(logRegistry);
+
+class PwRegistry;
+class PwMetadata;
+class PwNode;
+class PwLink;
+class PwLinkGroup;
+
+class PwBindableObject: public QObject {
+	Q_OBJECT;
+
+public:
+	PwBindableObject() = default;
+	~PwBindableObject() override;
+	Q_DISABLE_COPY_MOVE(PwBindableObject);
+
+	// constructors and destructors can't do virtual calls.
+	virtual void init(PwRegistry* registry, quint32 id, quint32 perms);
+	virtual void initProps(const spa_dict* /*props*/) {}
+	virtual void safeDestroy();
+
+	quint32 id = 0;
+	quint32 perms = 0;
+
+	void debugId(QDebug& debug) const;
+	void ref();
+	void unref();
+
+signals:
+	// goes with safeDestroy
+	void destroying(PwBindableObject* self);
+
+protected:
+	virtual void bind();
+	void unbind();
+	virtual void bindHooks() {};
+	virtual void unbindHooks() {};
+
+	quint32 refcount = 0;
+	pw_proxy* object = nullptr;
+	PwRegistry* registry = nullptr;
+};
+
+QDebug operator<<(QDebug debug, const PwBindableObject* object);
+
+template <typename T, const char* INTERFACE, quint32 VERSION>
+class PwBindable: public PwBindableObject {
+public:
+	T* proxy() {
+		return reinterpret_cast<T*>(this->object); // NOLINT
+	}
+
+protected:
+	void bind() override {
+		if (this->object != nullptr) return;
+		auto* object =
+		    pw_registry_bind(this->registry->object, this->id, INTERFACE, VERSION, 0); // NOLINT
+		this->object = static_cast<pw_proxy*>(object);
+		this->PwBindableObject::bind();
+	}
+
+	friend class PwRegistry;
+};
+
+class PwBindableObjectRef: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwBindableObjectRef(PwBindableObject* object = nullptr);
+	~PwBindableObjectRef() override;
+	Q_DISABLE_COPY_MOVE(PwBindableObjectRef);
+
+signals:
+	void objectDestroyed();
+
+private slots:
+	void onObjectDestroyed();
+
+protected:
+	void setObject(PwBindableObject* object);
+
+	PwBindableObject* mObject = nullptr;
+};
+
+template <typename T>
+class PwBindableRef: public PwBindableObjectRef {
+public:
+	explicit PwBindableRef(T* object = nullptr): PwBindableObjectRef(object) {}
+
+	void setObject(T* object) { this->PwBindableObjectRef::setObject(object); }
+
+	T* object() { return this->mObject; }
+};
+
+class PwRegistry
+    : public QObject
+    , public PwObject<pw_registry> {
+	Q_OBJECT;
+
+public:
+	void init(PwCore& core);
+
+	//QHash<quint32, PwClient*> clients;
+	QHash<quint32, PwMetadata*> metadata;
+	QHash<quint32, PwNode*> nodes;
+	QHash<quint32, PwLink*> links;
+	QVector<PwLinkGroup*> linkGroups;
+
+signals:
+	void nodeAdded(PwNode* node);
+	void linkAdded(PwLink* link);
+	void linkGroupAdded(PwLinkGroup* group);
+	void metadataUpdate(
+	    PwMetadata* owner,
+	    quint32 subject,
+	    const char* key,
+	    const char* type,
+	    const char* value
+	);
+
+private slots:
+	void onLinkGroupDestroyed(QObject* object);
+
+private:
+	static const pw_registry_events EVENTS;
+
+	static void onGlobal(
+	    void* data,
+	    quint32 id,
+	    quint32 permissions,
+	    const char* type,
+	    quint32 version,
+	    const spa_dict* props
+	);
+
+	static void onGlobalRemoved(void* data, quint32 id);
+
+	void addLinkToGroup(PwLink* link);
+
+	SpaHook listener;
+};
+
+} // namespace qs::service::pipewire

src/services/status_notifier/module.md

@@ -1,4 +1,4 @@
-name = "Quickshell.Service.SystemTray"
+name = "Quickshell.Services.SystemTray"
 description = "Types for implementing a system tray"
 headers = [ "qml.hpp" ]
 -----