Joren/pwweb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9dc685acdaa56106ea24d0815864b310d87a1cd7
pwweb/src/graph_engine.cpp
joren 2879469d13 feat: create virtual devices (+ Add Device dropdown) 
Backend:
- POST /api/create-null-sink {name} - loads null-sink module
- POST /api/create-loopback {name} - loads loopback module
- POST /api/unload-module {module_id} - unloads a module
- Fixed double-proxy-destroy crash in GraphEngine
- Graceful failure when module not available (no crash)

Frontend:
- + Add Device button in toolbar with dropdown menu
- Null Sink option (creates virtual audio output)
- Loopback Device option (creates paired input+output)
- Dropdown closes on outside click

Note: null-sink requires libpipewire-module-null-sink to be installed.
Loopback works on all PipeWire installations.
2026-03-29 23:50:01 +02:00

902 lines
29 KiB
C++
Raw Blame History

#include "graph_engine.h"
#include <pipewire/pipewire.h>
#include <pipewire/impl-module.h>
#include <pipewire/global.h>
#include <spa/utils/result.h>
#include <spa/utils/list.h>
#include <spa/param/props.h>
#include <spa/pod/pod.h>
#include <spa/pod/builder.h>
#include <spa/pod/iter.h>
#include <cstring>
#include <algorithm>
#include <chrono>
#include <thread>
// Default port type strings (must match qpwgraph)
#define DEFAULT_AUDIO_TYPE "32 bit float mono audio"
#define DEFAULT_MIDI_TYPE "8 bit raw midi"
#define DEFAULT_MIDI2_TYPE "32 bit raw UMP"
#define DEFAULT_VIDEO_TYPE "32 bit float RGBA video"
#define DEFAULT_OTHER_TYPE "PIPEWIRE_PORT_TYPE"
using namespace pwgraph;
// ============================================================================
// Pending/sync helpers (ported from qpwgraph_pipewire.cpp)
// ============================================================================
static void add_pending(GraphEngine::Object *obj, GraphEngine::PwData &pw) {
if (obj->pending_seq == 0)
spa_list_append(&pw.pending, &obj->pending_link);
obj->pending_seq = pw_core_sync(pw.core, 0, obj->pending_seq);
pw.pending_seq = obj->pending_seq;
}
static void remove_pending(GraphEngine::Object *obj) {
if (obj->pending_seq != 0) {
spa_list_remove(&obj->pending_link);
obj->pending_seq = 0;
}
}
// ============================================================================
// Proxy helpers
// ============================================================================
static void destroy_proxy(GraphEngine::Object *obj) {
pw_proxy *proxy = (pw_proxy*)obj->proxy;
if (proxy) {
obj->proxy = nullptr;
pw_proxy_destroy(proxy);
}
if (obj->object_listener.link.next) {
spa_hook_remove(&obj->object_listener);
spa_zero(obj->object_listener);
}
if (obj->proxy_listener.link.next) {
spa_hook_remove(&obj->proxy_listener);
spa_zero(obj->proxy_listener);
}
remove_pending(obj);
if (obj->info && obj->destroy_info) {
obj->destroy_info(obj->info);
obj->info = nullptr;
}
}
// ============================================================================
// Node events (ported from qpwgraph_pipewire.cpp lines 224-278)
// ============================================================================
static void on_node_info(void *data, const struct pw_node_info *info) {
auto *obj = static_cast<GraphEngine::Object*>(data);
if (!obj) return;
info = pw_node_info_update((struct pw_node_info*)obj->info, info);
obj->info = (void*)info;
auto *nobj = static_cast<GraphEngine::NodeObj*>(obj);
if (info && (info->change_mask & PW_NODE_CHANGE_MASK_PROPS)) {
if (info->props) {
const char *media_name = spa_dict_lookup(info->props, PW_KEY_MEDIA_NAME);
if (media_name && strlen(media_name) > 0)
nobj->node.media_name = media_name;
// Read volume from props
const char *vol_str = spa_dict_lookup(info->props, "volume");
if (vol_str) {
nobj->node.volume = pw_properties_parse_float(vol_str);
}
// Read mute from props
const char *mute_str = spa_dict_lookup(info->props, "mute");
if (mute_str) {
nobj->node.mute = pw_properties_parse_bool(mute_str);
}
}
}
nobj->node.changed = true;
nobj->node.ready = true;
}
static const struct pw_node_events node_events = {
.version = PW_VERSION_NODE_EVENTS,
.info = on_node_info,
};
// ============================================================================
// Port events
// ============================================================================
static void on_port_info(void *data, const struct pw_port_info *info) {
auto *obj = static_cast<GraphEngine::Object*>(data);
if (!obj) return;
info = pw_port_info_update((struct pw_port_info*)obj->info, info);
obj->info = (void*)info;
}
static const struct pw_port_events port_events = {
.version = PW_VERSION_PORT_EVENTS,
.info = on_port_info,
};
// ============================================================================
// Link events
// ============================================================================
static void on_link_info(void *data, const struct pw_link_info *info) {
auto *obj = static_cast<GraphEngine::Object*>(data);
if (!obj) return;
info = pw_link_info_update((struct pw_link_info*)obj->info, info);
obj->info = (void*)info;
}
static const struct pw_link_events link_events = {
.version = PW_VERSION_LINK_EVENTS,
.info = on_link_info,
};
// ============================================================================
// Proxy events
// ============================================================================
static void on_proxy_removed(void *data) {
auto *obj = static_cast<GraphEngine::Object*>(data);
if (obj && obj->proxy) {
pw_proxy *proxy = (pw_proxy*)obj->proxy;
obj->proxy = nullptr;
pw_proxy_destroy(proxy);
}
}
static void on_proxy_destroy(void *data) {
auto *obj = static_cast<GraphEngine::Object*>(data);
if (obj)
destroy_proxy(obj);
}
static const struct pw_proxy_events proxy_events = {
.version = PW_VERSION_PROXY_EVENTS,
.destroy = on_proxy_destroy,
.removed = on_proxy_removed,
};
// ============================================================================
// Object proxy creation (adapted from qpwgraph_pipewire::Object::create_proxy)
// ============================================================================
static void create_proxy_for_object(GraphEngine::Object *obj, GraphEngine *engine) {
if (obj->proxy) return;
const char *proxy_type = nullptr;
uint32_t version = 0;
void (*destroy_info)(void*) = nullptr;
const void *events = nullptr;
switch (obj->type) {
case GraphEngine::Object::ObjNode:
proxy_type = PW_TYPE_INTERFACE_Node;
version = PW_VERSION_NODE;
destroy_info = (void(*)(void*))pw_node_info_free;
events = &node_events;
break;
case GraphEngine::Object::ObjPort:
proxy_type = PW_TYPE_INTERFACE_Port;
version = PW_VERSION_PORT;
destroy_info = (void(*)(void*))pw_port_info_free;
events = &port_events;
break;
case GraphEngine::Object::ObjLink:
proxy_type = PW_TYPE_INTERFACE_Link;
version = PW_VERSION_LINK;
destroy_info = (void(*)(void*))pw_link_info_free;
events = &link_events;
break;
}
auto &pw = engine->pwData();
pw_proxy *proxy = (pw_proxy*)pw_registry_bind(
pw.registry, obj->id, proxy_type, version, 0);
if (proxy) {
obj->proxy = proxy;
obj->destroy_info = destroy_info;
obj->pending_seq = 0;
pw_proxy_add_object_listener(proxy,
&obj->object_listener, events, obj);
pw_proxy_add_listener(proxy,
&obj->proxy_listener, &proxy_events, obj);
}
}
// ============================================================================
// Core events (sync/error handling)
// ============================================================================
static void on_core_done(void *data, uint32_t id, int seq) {
auto *engine = static_cast<GraphEngine*>(data);
auto &pw = engine->pwData();
if (id == PW_ID_CORE) {
pw.last_seq = seq;
if (pw.pending_seq == seq)
pw_thread_loop_signal(pw.loop, false);
}
}
static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message) {
auto *engine = static_cast<GraphEngine*>(data);
auto &pw = engine->pwData();
if (id == PW_ID_CORE) {
pw.last_res = res;
if (res == -EPIPE)
pw.error = true;
}
pw_thread_loop_signal(pw.loop, false);
}
static const struct pw_core_events core_events = {
.version = PW_VERSION_CORE_EVENTS,
.info = nullptr,
.done = on_core_done,
.error = on_core_error,
};
// ============================================================================
// Link proxy sync (for connect/disconnect operations)
// ============================================================================
static int link_proxy_sync(GraphEngine *engine) {
auto &pw = engine->pwData();
if (pw_thread_loop_in_thread(pw.loop))
return 0;
pw.pending_seq = pw_proxy_sync((pw_proxy*)pw.core, pw.pending_seq);
while (true) {
pw_thread_loop_wait(pw.loop);
if (pw.error)
return pw.last_res;
if (pw.pending_seq == pw.last_seq)
break;
}
return 0;
}
static void on_link_proxy_error(void *data, int seq, int res, const char *message) {
int *link_res = (int*)data;
*link_res = res;
}
static const struct pw_proxy_events link_proxy_events = {
.version = PW_VERSION_PROXY_EVENTS,
.error = on_link_proxy_error,
};
// ============================================================================
// Registry events (the main entry point — ported from qpwgraph lines 425-568)
// ============================================================================
static void on_registry_global(void *data,
uint32_t id, uint32_t permissions,
const char *type, uint32_t version,
const struct spa_dict *props)
{
if (!props) return;
auto *engine = static_cast<GraphEngine*>(data);
if (strcmp(type, PW_TYPE_INTERFACE_Node) == 0) {
// Parse node properties (ported from qpwgraph lines 444-489)
const char *str = spa_dict_lookup(props, PW_KEY_NODE_DESCRIPTION);
const char *nick = spa_dict_lookup(props, PW_KEY_NODE_NICK);
if (!str || strlen(str) < 1) str = nick;
if (!str || strlen(str) < 1) str = nick = spa_dict_lookup(props, PW_KEY_NODE_NAME);
if (!str || strlen(str) < 1) str = "node";
std::string node_name;
const char *app = spa_dict_lookup(props, PW_KEY_APP_NAME);
if (app && strlen(app) > 0 && strcmp(app, str) != 0) {
node_name += app;
node_name += '/';
}
node_name += str;
std::string node_nick = (nick ? nick : str);
PortMode node_mode = PortMode::None;
uint8_t node_types = 0;
str = spa_dict_lookup(props, PW_KEY_MEDIA_CLASS);
if (str) {
if (strstr(str, "Source") || strstr(str, "Output"))
node_mode = PortMode::Output;
else if (strstr(str, "Sink") || strstr(str, "Input"))
node_mode = PortMode::Input;
if (strstr(str, "Audio")) node_types |= (uint8_t)NodeType::Audio;
if (strstr(str, "Video")) node_types |= (uint8_t)NodeType::Video;
if (strstr(str, "Midi")) node_types |= (uint8_t)NodeType::Midi;
}
if (node_mode == PortMode::None) {
str = spa_dict_lookup(props, PW_KEY_MEDIA_CATEGORY);
if (str && strstr(str, "Duplex"))
node_mode = PortMode::Duplex;
}
// Create node object
auto *nobj = new GraphEngine::NodeObj(id);
nobj->node.id = id;
nobj->node.name = node_name;
nobj->node.nick = node_nick;
nobj->node.mode = node_mode;
nobj->node.node_type = NodeType(node_types);
nobj->node.mode2 = node_mode;
nobj->node.ready = false;
nobj->node.changed = false;
engine->addObject(id, nobj);
create_proxy_for_object(nobj, engine);
engine->notifyChanged();
}
else if (strcmp(type, PW_TYPE_INTERFACE_Port) == 0) {
// Parse port properties (ported from qpwgraph lines 492-535)
const char *str = spa_dict_lookup(props, PW_KEY_NODE_ID);
const uint32_t node_id = (str ? (uint32_t)atoi(str) : 0);
std::string port_name;
str = spa_dict_lookup(props, PW_KEY_PORT_ALIAS);
if (!str) str = spa_dict_lookup(props, PW_KEY_PORT_NAME);
if (!str) str = "port";
port_name = str;
auto *node_obj = engine->findNode(node_id);
uint32_t port_type = engine->otherPortType();
str = spa_dict_lookup(props, PW_KEY_FORMAT_DSP);
if (str) {
port_type = hashType(str);
} else if (node_obj && (node_obj->node.node_type & NodeType::Video) != NodeType::None) {
port_type = engine->videoPortType();
}
PortMode port_mode = PortMode::None;
str = spa_dict_lookup(props, PW_KEY_PORT_DIRECTION);
if (str) {
if (strcmp(str, "in") == 0) port_mode = PortMode::Input;
else if (strcmp(str, "out") == 0) port_mode = PortMode::Output;
}
uint8_t port_flags = 0;
if (node_obj && (node_obj->node.mode2 != PortMode::Duplex))
port_flags |= (uint8_t)PortFlags::Terminal;
str = spa_dict_lookup(props, PW_KEY_PORT_PHYSICAL);
if (str && pw_properties_parse_bool(str))
port_flags |= (uint8_t)PortFlags::Physical;
str = spa_dict_lookup(props, PW_KEY_PORT_TERMINAL);
if (str && pw_properties_parse_bool(str))
port_flags |= (uint8_t)PortFlags::Terminal;
str = spa_dict_lookup(props, PW_KEY_PORT_MONITOR);
if (str && pw_properties_parse_bool(str))
port_flags |= (uint8_t)PortFlags::Monitor;
str = spa_dict_lookup(props, PW_KEY_PORT_CONTROL);
if (str && pw_properties_parse_bool(str))
port_flags |= (uint8_t)PortFlags::Control;
if (!node_obj) return; // Node not ready yet
auto *pobj = new GraphEngine::PortObj(id);
pobj->port.id = id;
pobj->port.node_id = node_id;
pobj->port.name = port_name;
pobj->port.mode = port_mode;
pobj->port.port_type = port_type;
pobj->port.flags = PortFlags(port_flags);
// Update node's mode2 if port direction differs
if ((node_obj->node.mode2 & port_mode) == PortMode::None)
node_obj->node.mode2 = PortMode::Duplex;
node_obj->node.port_ids.push_back(id);
node_obj->node.changed = true;
engine->addObject(id, pobj);
create_proxy_for_object(pobj, engine);
engine->notifyChanged();
}
else if (strcmp(type, PW_TYPE_INTERFACE_Link) == 0) {
// Parse link properties (ported from qpwgraph lines 538-545)
const char *str = spa_dict_lookup(props, PW_KEY_LINK_OUTPUT_PORT);
const uint32_t port1_id = (str ? (uint32_t)pw_properties_parse_int(str) : 0);
str = spa_dict_lookup(props, PW_KEY_LINK_INPUT_PORT);
const uint32_t port2_id = (str ? (uint32_t)pw_properties_parse_int(str) : 0);
// Validate
auto *p1 = engine->findPort(port1_id);
auto *p2 = engine->findPort(port2_id);
if (!p1 || !p2) return;
if ((p1->port.mode & PortMode::Output) == PortMode::None) return;
if ((p2->port.mode & PortMode::Input) == PortMode::None) return;
auto *lobj = new GraphEngine::LinkObj(id);
lobj->link.id = id;
lobj->link.port1_id = port1_id;
lobj->link.port2_id = port2_id;
p1->port.link_ids.push_back(id);
engine->addObject(id, lobj);
create_proxy_for_object(lobj, engine);
engine->notifyChanged();
}
}
static void on_registry_global_remove(void *data, uint32_t id) {
auto *engine = static_cast<GraphEngine*>(data);
engine->removeObject(id);
engine->notifyChanged();
}
static const struct pw_registry_events registry_events = {
.version = PW_VERSION_REGISTRY_EVENTS,
.global = on_registry_global,
.global_remove = on_registry_global_remove,
};
// ============================================================================
// GraphEngine::Object
// ============================================================================
GraphEngine::Object::Object(uint32_t id, Type type)
: id(id), type(type), proxy(nullptr), info(nullptr),
destroy_info(nullptr), pending_seq(0)
{
spa_zero(proxy_listener);
spa_zero(object_listener);
spa_list_init(&pending_link);
}
GraphEngine::Object::~Object() {
if (proxy) {
destroy_proxy(this);
}
}
// ============================================================================
// GraphEngine
// ============================================================================
GraphEngine::GraphEngine()
: m_on_change(nullptr), m_running(false)
{
m_audio_type = hashType(DEFAULT_AUDIO_TYPE);
m_midi_type = hashType(DEFAULT_MIDI_TYPE);
m_midi2_type = hashType(DEFAULT_MIDI2_TYPE);
m_video_type = hashType(DEFAULT_VIDEO_TYPE);
m_other_type = hashType(DEFAULT_OTHER_TYPE);
memset(&m_pw, 0, sizeof(m_pw));
spa_list_init(&m_pw.pending);
}
GraphEngine::~GraphEngine() {
close();
}
bool GraphEngine::open() {
std::lock_guard<std::mutex> lock(m_mutex);
pw_init(nullptr, nullptr);
memset(&m_pw, 0, sizeof(m_pw));
spa_list_init(&m_pw.pending);
m_pw.pending_seq = 0;
m_pw.loop = pw_thread_loop_new("pwweb_loop", nullptr);
if (!m_pw.loop) {
fprintf(stderr, "pw_thread_loop_new failed\n");
pw_deinit();
return false;
}
pw_thread_loop_lock(m_pw.loop);
struct pw_loop *loop = pw_thread_loop_get_loop(m_pw.loop);
m_pw.context = pw_context_new(loop, nullptr, 0);
if (!m_pw.context) {
fprintf(stderr, "pw_context_new failed\n");
pw_thread_loop_unlock(m_pw.loop);
pw_thread_loop_destroy(m_pw.loop);
pw_deinit();
return false;
}
m_pw.core = pw_context_connect(m_pw.context, nullptr, 0);
if (!m_pw.core) {
fprintf(stderr, "pw_context_connect failed\n");
pw_thread_loop_unlock(m_pw.loop);
pw_context_destroy(m_pw.context);
pw_thread_loop_destroy(m_pw.loop);
pw_deinit();
return false;
}
pw_core_add_listener(m_pw.core,
&m_pw.core_listener, &core_events, this);
m_pw.registry = pw_core_get_registry(m_pw.core,
PW_VERSION_REGISTRY, 0);
pw_registry_add_listener(m_pw.registry,
&m_pw.registry_listener, &registry_events, this);
m_pw.pending_seq = 0;
m_pw.last_seq = 0;
m_pw.last_res = 0;
m_pw.error = false;
m_running = true;
pw_thread_loop_start(m_pw.loop);
pw_thread_loop_unlock(m_pw.loop);
fprintf(stderr, "pwweb: PipeWire connected\n");
return true;
}
void GraphEngine::close() {
if (!m_pw.loop) return;
m_running = false;
pw_thread_loop_lock(m_pw.loop);
clearObjects();
pw_thread_loop_unlock(m_pw.loop);
if (m_pw.loop)
pw_thread_loop_stop(m_pw.loop);
if (m_pw.registry) {
spa_hook_remove(&m_pw.registry_listener);
pw_proxy_destroy((pw_proxy*)m_pw.registry);
}
if (m_pw.core) {
spa_hook_remove(&m_pw.core_listener);
pw_core_disconnect(m_pw.core);
}
if (m_pw.context)
pw_context_destroy(m_pw.context);
if (m_pw.loop)
pw_thread_loop_destroy(m_pw.loop);
memset(&m_pw, 0, sizeof(m_pw));
pw_deinit();
fprintf(stderr, "pwweb: PipeWire disconnected\n");
}
void GraphEngine::setOnChange(ChangeCallback cb) {
std::lock_guard<std::mutex> lock(m_mutex);
m_on_change = std::move(cb);
}
void GraphEngine::notifyChanged() {
// Called from PipeWire thread — invoke callback outside lock
ChangeCallback cb;
{
std::lock_guard<std::mutex> lock(m_mutex);
cb = m_on_change;
}
if (cb) cb();
}
// ============================================================================
// Object management
// ============================================================================
void GraphEngine::addObject(uint32_t id, Object *obj) {
m_objects_by_id[id] = obj;
m_objects.push_back(obj);
}
GraphEngine::Object *GraphEngine::findObject(uint32_t id) const {
auto it = m_objects_by_id.find(id);
return (it != m_objects_by_id.end()) ? it->second : nullptr;
}
void GraphEngine::removeObject(uint32_t id) {
auto it = m_objects_by_id.find(id);
if (it == m_objects_by_id.end()) return;
Object *obj = it->second;
m_objects_by_id.erase(it);
auto vit = std::find(m_objects.begin(), m_objects.end(), obj);
if (vit != m_objects.end())
m_objects.erase(vit);
// If it's a port, remove from parent node's port list
if (obj->type == Object::ObjPort) {
auto *pobj = static_cast<PortObj*>(obj);
auto *nobj = findNode(pobj->port.node_id);
if (nobj) {
auto &pids = nobj->node.port_ids;
pids.erase(std::remove(pids.begin(), pids.end(), id), pids.end());
nobj->node.changed = true;
}
// Remove any links involving this port
auto link_ids_copy = pobj->port.link_ids;
for (uint32_t lid : link_ids_copy) {
removeObject(lid);
}
}
// If it's a node, remove all its ports
if (obj->type == Object::ObjNode) {
auto *nobj = static_cast<NodeObj*>(obj);
auto port_ids_copy = nobj->node.port_ids;
for (uint32_t pid : port_ids_copy) {
removeObject(pid);
}
}
// If it's a link, remove from output port's link list
if (obj->type == Object::ObjLink) {
auto *lobj = static_cast<LinkObj*>(obj);
auto *pobj = findPort(lobj->link.port1_id);
if (pobj) {
auto &lids = pobj->port.link_ids;
lids.erase(std::remove(lids.begin(), lids.end(), id), lids.end());
}
}
delete obj;
}
void GraphEngine::clearObjects() {
for (auto *obj : m_objects)
delete obj;
m_objects.clear();
m_objects_by_id.clear();
}
GraphEngine::NodeObj *GraphEngine::findNode(uint32_t node_id) const {
Object *obj = findObject(node_id);
return (obj && obj->type == Object::ObjNode) ? static_cast<NodeObj*>(obj) : nullptr;
}
GraphEngine::PortObj *GraphEngine::findPort(uint32_t port_id) const {
Object *obj = findObject(port_id);
return (obj && obj->type == Object::ObjPort) ? static_cast<PortObj*>(obj) : nullptr;
}
GraphEngine::LinkObj *GraphEngine::findLink(uint32_t link_id) const {
Object *obj = findObject(link_id);
return (obj && obj->type == Object::ObjLink) ? static_cast<LinkObj*>(obj) : nullptr;
}
// ============================================================================
// Snapshot (thread-safe graph state)
// ============================================================================
GraphEngine::Snapshot GraphEngine::snapshot() const {
std::lock_guard<std::mutex> lock(m_mutex);
Snapshot snap;
for (auto *obj : m_objects) {
switch (obj->type) {
case Object::ObjNode:
snap.nodes.push_back(static_cast<NodeObj*>(obj)->node);
break;
case Object::ObjPort:
snap.ports.push_back(static_cast<PortObj*>(obj)->port);
break;
case Object::ObjLink:
snap.links.push_back(static_cast<LinkObj*>(obj)->link);
break;
}
}
return snap;
}
// ============================================================================
// Connect/Disconnect (ported from qpwgraph_pipewire::connectPorts)
// ============================================================================
bool GraphEngine::connectPorts(uint32_t output_port_id, uint32_t input_port_id) {
if (!m_pw.loop) return false;
pw_thread_loop_lock(m_pw.loop);
PortObj *p1 = findPort(output_port_id);
PortObj *p2 = findPort(input_port_id);
if (!p1 || !p2 ||
(p1->port.mode & PortMode::Output) == PortMode::None ||
(p2->port.mode & PortMode::Input) == PortMode::None ||
p1->port.port_type != p2->port.port_type) {
pw_thread_loop_unlock(m_pw.loop);
return false;
}
// Create link via PipeWire (adapted from qpwgraph lines 858-891)
char val[4][16];
snprintf(val[0], sizeof(val[0]), "%u", p1->port.node_id);
snprintf(val[1], sizeof(val[1]), "%u", p1->id);
snprintf(val[2], sizeof(val[2]), "%u", p2->port.node_id);
snprintf(val[3], sizeof(val[3]), "%u", p2->id);
struct spa_dict props;
struct spa_dict_item items[6];
props = SPA_DICT_INIT(items, 0);
items[props.n_items++] = SPA_DICT_ITEM_INIT(PW_KEY_LINK_OUTPUT_NODE, val[0]);
items[props.n_items++] = SPA_DICT_ITEM_INIT(PW_KEY_LINK_OUTPUT_PORT, val[1]);
items[props.n_items++] = SPA_DICT_ITEM_INIT(PW_KEY_LINK_INPUT_NODE, val[2]);
items[props.n_items++] = SPA_DICT_ITEM_INIT(PW_KEY_LINK_INPUT_PORT, val[3]);
items[props.n_items++] = SPA_DICT_ITEM_INIT(PW_KEY_OBJECT_LINGER, "true");
const char *str = getenv("PIPEWIRE_LINK_PASSIVE");
if (str && pw_properties_parse_bool(str))
items[props.n_items++] = SPA_DICT_ITEM_INIT(PW_KEY_LINK_PASSIVE, "true");
pw_proxy *proxy = (pw_proxy*)pw_core_create_object(m_pw.core,
"link-factory", PW_TYPE_INTERFACE_Link, PW_VERSION_LINK, &props, 0);
if (proxy) {
int link_res = 0;
spa_hook listener;
spa_zero(listener);
pw_proxy_add_listener(proxy,
&listener, &link_proxy_events, &link_res);
link_proxy_sync(this);
spa_hook_remove(&listener);
pw_proxy_destroy(proxy);
}
pw_thread_loop_unlock(m_pw.loop);
return (proxy != nullptr);
}
bool GraphEngine::disconnectPorts(uint32_t output_port_id, uint32_t input_port_id) {
if (!m_pw.loop) return false;
pw_thread_loop_lock(m_pw.loop);
PortObj *p1 = findPort(output_port_id);
PortObj *p2 = findPort(input_port_id);
if (!p1 || !p2) {
pw_thread_loop_unlock(m_pw.loop);
return false;
}
// Find and destroy matching link (adapted from qpwgraph lines 846-853)
bool found = false;
for (uint32_t lid : p1->port.link_ids) {
LinkObj *link = findLink(lid);
if (link && link->link.port1_id == output_port_id &&
link->link.port2_id == input_port_id) {
pw_registry_destroy(m_pw.registry, lid);
link_proxy_sync(this);
found = true;
break;
}
}
pw_thread_loop_unlock(m_pw.loop);
return found;
}
// ============================================================================
// Volume control
// ============================================================================
bool GraphEngine::setNodeVolume(uint32_t node_id, float volume) {
if (!m_pw.loop) return false;
pw_thread_loop_lock(m_pw.loop);
NodeObj *nobj = findNode(node_id);
if (!nobj || !nobj->proxy) {
pw_thread_loop_unlock(m_pw.loop);
return false;
}
// Build Props param with volume
uint8_t buf[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
struct spa_pod_frame f;
spa_pod_builder_push_object(&b, &f, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props);
spa_pod_builder_prop(&b, SPA_PROP_volume, 0);
spa_pod_builder_float(&b, volume);
struct spa_pod *param = (struct spa_pod*)spa_pod_builder_pop(&b, &f);
pw_node_set_param((pw_node*)nobj->proxy,
SPA_PARAM_Props, 0, param);
nobj->node.volume = volume;
nobj->node.changed = true;
pw_thread_loop_unlock(m_pw.loop);
return true;
}
bool GraphEngine::setNodeMute(uint32_t node_id, bool mute) {
if (!m_pw.loop) return false;
pw_thread_loop_lock(m_pw.loop);
NodeObj *nobj = findNode(node_id);
if (!nobj || !nobj->proxy) {
pw_thread_loop_unlock(m_pw.loop);
return false;
}
uint8_t buf[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
struct spa_pod_frame f;
spa_pod_builder_push_object(&b, &f, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props);
spa_pod_builder_prop(&b, SPA_PROP_mute, 0);
spa_pod_builder_bool(&b, mute);
struct spa_pod *param = (struct spa_pod*)spa_pod_builder_pop(&b, &f);
pw_node_set_param((pw_node*)nobj->proxy,
SPA_PARAM_Props, 0, param);
nobj->node.mute = mute;
nobj->node.changed = true;
pw_thread_loop_unlock(m_pw.loop);
return true;
}
// ============================================================================
// Module loading (virtual devices)
// ============================================================================
uint32_t GraphEngine::loadModule(const char *name, const char *args) {
if (!m_pw.loop || !m_pw.context) return 0;
pw_thread_loop_lock(m_pw.loop);
struct pw_impl_module *mod = pw_context_load_module(m_pw.context, name, args, nullptr);
uint32_t id = 0;
if (!mod) {
fprintf(stderr, "pwweb: failed to load module %s\n", name);
} else {
struct pw_global *global = pw_impl_module_get_global(mod);
if (global) {
id = pw_global_get_id(global);
}
fprintf(stderr, "pwweb: loaded module %s (id=%u)\n", name, id);
}
pw_thread_loop_unlock(m_pw.loop);
return id;
}
bool GraphEngine::unloadModule(uint32_t module_id) {
if (!m_pw.loop || !m_pw.registry) return false;
pw_thread_loop_lock(m_pw.loop);
pw_registry_destroy(m_pw.registry, module_id);
pw_thread_loop_unlock(m_pw.loop);
fprintf(stderr, "pwweb: unloaded module id=%u\n", module_id);
return true;
}
// end of graph_engine.cpp
Reference in New Issue View Git Blame Copy Permalink