Adding upstream version 0.3.65.upstream/0.3.65upstream

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

1 files changed, 1169 insertions, 0 deletions

diff --git a/src/tools/pw-dot.c b/src/tools/pw-dot.c
new file mode 100644
index 0000000..30eb780
--- /dev/null
+++ b/src/tools/pw-dot.c
@@ -0,0 +1,1169 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Collabora Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <signal.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/string.h>
+#include <spa/utils/json.h>
+#include <spa/debug/types.h>
+
+#include <pipewire/pipewire.h>
+
+#define GLOBAL_ID_NONE UINT32_MAX
+#define DEFAULT_DOT_PATH "pw.dot"
+
+struct global;
+
+typedef void (*draw_t)(struct global *g);
+typedef void *(*info_update_t) (void *info, const void *update);
+
+struct data {
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+
+	struct pw_core *core;
+	struct spa_hook core_listener;
+
+	struct pw_registry *registry;
+	struct spa_hook registry_listener;
+
+	struct spa_list globals;
+	char *dot_str;
+	const char *dot_rankdir;
+	bool dot_orthoedges;
+
+	bool show_all;
+	bool show_smart;
+	bool show_detail;
+};
+
+struct global {
+	struct spa_list link;
+
+	struct data *data;
+	struct pw_proxy *proxy;
+
+	uint32_t id;
+#define INTERFACE_Port		0
+#define INTERFACE_Node		1
+#define INTERFACE_Link		2
+#define INTERFACE_Client	3
+#define INTERFACE_Device	4
+#define INTERFACE_Module	5
+#define INTERFACE_Factory	6
+	uint32_t type;
+	void *info;
+
+	pw_destroy_t info_destroy;
+	info_update_t info_update;
+	draw_t draw;
+
+	struct spa_hook proxy_listener;
+	struct spa_hook object_listener;
+};
+
+static char *dot_str_new(void)
+{
+        return strdup("");
+}
+
+static void dot_str_clear(char **str)
+{
+	if (str && *str) {
+		  free(*str);
+		  *str = NULL;
+	}
+}
+
+static SPA_PRINTF_FUNC(2,0) void dot_str_vadd(char **str, const char *fmt, va_list varargs)
+{
+	char *res = NULL;
+	char *fmt2 = NULL;
+
+	spa_return_if_fail(str != NULL);
+	spa_return_if_fail(fmt != NULL);
+
+	if (asprintf(&fmt2, "%s%s", *str, fmt) < 0) {
+		spa_assert_not_reached();
+		return;
+	}
+
+	if (vasprintf(&res, fmt2, varargs) < 0) {
+		free (fmt2);
+		spa_assert_not_reached();
+		return;
+	}
+	free (fmt2);
+
+	free(*str);
+	*str = res;
+}
+
+static SPA_PRINTF_FUNC(2,3) void dot_str_add(char **str, const char *fmt, ...)
+{
+	va_list varargs;
+	va_start(varargs, fmt);
+	dot_str_vadd(str, fmt, varargs);
+	va_end(varargs);
+}
+
+static void draw_dict(char **str, const char *title,
+		      const struct spa_dict *props)
+{
+	const struct spa_dict_item *item;
+
+	dot_str_add(str, "%s:\\l", title);
+	if (props == NULL || props->n_items == 0) {
+		dot_str_add(str, "- none\\l");
+		return;
+	}
+
+	spa_dict_for_each(item, props) {
+		if (item->value)
+			dot_str_add(str, "- %s: %s\\l", item->key, item->value);
+		else
+			dot_str_add(str, "- %s: (null)\\l", item->key);
+	}
+}
+
+static SPA_PRINTF_FUNC(6,0) void draw_vlabel(char **str, const char *name, uint32_t id, bool detail,
+		       const struct spa_dict *props, const char *fmt, va_list varargs)
+{
+	/* draw the label header */
+	dot_str_add(str, "%s_%u [label=\"", name, id);
+
+	/* draw the label body */
+	dot_str_vadd(str, fmt, varargs);
+
+	if (detail)
+		draw_dict(str, "properties", props);
+
+	/*draw the label footer */
+	dot_str_add(str, "%s", "\"];\n");
+}
+
+static SPA_PRINTF_FUNC(6,7) void draw_label(char **str, const char *name, uint32_t id, bool detail,
+		       const struct spa_dict *props, const char *fmt, ...)
+{
+	va_list varargs;
+	va_start(varargs, fmt);
+	draw_vlabel(str, name, id, detail, props, fmt, varargs);
+	va_end(varargs);
+}
+
+static void draw_port(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Port);
+
+	struct pw_port_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str,
+		"port_%u [shape=box style=filled fillcolor=%s];\n",
+		g->id,
+		info->direction == PW_DIRECTION_INPUT ? "lightslateblue" : "lightcoral"
+	);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"port", g->id, g->data->show_detail, info->props,
+		"port_id: %u\\lname: %s\\ldirection: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_PORT_NAME),
+		pw_direction_as_string(info->direction)
+	);
+}
+
+
+static void draw_node(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Node);
+
+	struct pw_node_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	const char *client_id_str, *factory_id_str;
+	uint32_t client_id, factory_id;
+
+	client_id_str = spa_dict_lookup(info->props, PW_KEY_CLIENT_ID);
+	factory_id_str = spa_dict_lookup(info->props, PW_KEY_FACTORY_ID);
+	client_id = client_id_str ? (uint32_t)atoi(client_id_str) : GLOBAL_ID_NONE;
+	factory_id = factory_id_str ? (uint32_t)atoi(factory_id_str) : GLOBAL_ID_NONE;
+
+	/* draw the node header */
+	dot_str_add(dot_str, "subgraph cluster_node_%u {\n", g->id);
+	dot_str_add(dot_str, "bgcolor=palegreen;\n");
+
+	/* draw the label header */
+	dot_str_add(dot_str, "label=\"");
+
+	/* draw the label body */
+	dot_str_add(dot_str, "node_id: %u\\lname: %s\\lmedia_class: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_NODE_NAME),
+		spa_dict_lookup(info->props, PW_KEY_MEDIA_CLASS));
+
+	if (g->data->show_detail)
+		draw_dict(dot_str, "properties", info->props);
+
+	/*draw the label footer */
+	dot_str_add(dot_str, "%s", "\"\n");
+
+	/* draw all node ports */
+	struct global *p;
+	const char *prop_node_id;
+	spa_list_for_each(p, &g->data->globals, link) {
+		struct pw_port_info *pinfo;
+		if (p->info == NULL)
+			continue;
+		if (p->type != INTERFACE_Port)
+			continue;
+		pinfo = p->info;
+		prop_node_id = spa_dict_lookup(pinfo->props, PW_KEY_NODE_ID);
+		if (!prop_node_id || (uint32_t)atoi(prop_node_id) != g->id)
+			continue;
+		if (p->draw)
+			p->draw(p);
+	}
+
+	/* draw the client/factory box if all option is enabled */
+	if (g->data->show_all) {
+		dot_str_add(dot_str, "node_%u [shape=box style=filled fillcolor=white];\n", g->id);
+		dot_str_add(dot_str, "node_%u [label=\"client_id: %u\\lfactory_id: %u\\l\"];\n", g->id, client_id, factory_id);
+	}
+
+	/* draw the node footer */
+	dot_str_add(dot_str, "}\n");
+
+	/* draw the client/factory arrows if all option is enabled */
+	if (g->data->show_all) {
+		dot_str_add(dot_str, "node_%u -> client_%u [style=dashed];\n", g->id, client_id);
+		dot_str_add(dot_str, "node_%u -> factory_%u [style=dashed];\n", g->id, factory_id);
+	}
+}
+
+static void draw_link(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Link);
+
+	struct pw_link_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str, "link_%u [shape=box style=filled fillcolor=lightblue];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"link", g->id, g->data->show_detail, info->props,
+		"link_id: %u\\loutput_node_id: %u\\linput_node_id: %u\\loutput_port_id: %u\\linput_port_id: %u\\lstate: %s\\l",
+		g->id,
+		info->output_node_id,
+		info->input_node_id,
+		info->output_port_id,
+		info->input_port_id,
+		pw_link_state_as_string(info->state)
+	);
+
+	/* draw the arrows */
+	dot_str_add(dot_str, "port_%u -> link_%u -> port_%u;\n", info->output_port_id, g->id, info->input_port_id);
+}
+
+static void draw_client(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Client);
+
+	struct pw_client_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str, "client_%u [shape=box style=filled fillcolor=tan1];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"client", g->id, g->data->show_detail, info->props,
+		"client_id: %u\\lname: %s\\lpid: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_APP_NAME),
+		spa_dict_lookup(info->props, PW_KEY_APP_PROCESS_ID)
+	);
+}
+
+static void draw_device(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Device);
+
+	struct pw_device_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	const char *client_id_str = spa_dict_lookup(info->props, PW_KEY_CLIENT_ID);
+	const char *factory_id_str = spa_dict_lookup(info->props, PW_KEY_FACTORY_ID);
+	uint32_t client_id = client_id_str ? (uint32_t)atoi(client_id_str) : GLOBAL_ID_NONE;
+	uint32_t factory_id = factory_id_str ? (uint32_t)atoi(factory_id_str) : GLOBAL_ID_NONE;
+
+	/* draw the box */
+	dot_str_add(dot_str, "device_%u [shape=box style=filled fillcolor=lightpink];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"device", g->id, g->data->show_detail, info->props,
+		"device_id: %u\\lname: %s\\lmedia_class: %s\\lapi: %s\\lpath: %s\\l",
+		g->id,
+		spa_dict_lookup(info->props, PW_KEY_DEVICE_NAME),
+		spa_dict_lookup(info->props, PW_KEY_MEDIA_CLASS),
+		spa_dict_lookup(info->props, PW_KEY_DEVICE_API),
+		spa_dict_lookup(info->props, PW_KEY_OBJECT_PATH)
+	);
+
+	/* draw the arrows */
+	dot_str_add(dot_str, "device_%u -> client_%u [style=dashed];\n", g->id, client_id);
+	dot_str_add(dot_str, "device_%u -> factory_%u [style=dashed];\n", g->id, factory_id);
+}
+
+static void draw_factory(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Factory);
+
+	struct pw_factory_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	const char *module_id_str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID);
+	uint32_t module_id = module_id_str ? (uint32_t)atoi(module_id_str) : GLOBAL_ID_NONE;
+
+	/* draw the box */
+	dot_str_add(dot_str, "factory_%u [shape=box style=filled fillcolor=lightyellow];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"factory", g->id, g->data->show_detail, info->props,
+		"factory_id: %u\\lname: %s\\lmodule_id: %u\\l",
+		g->id, info->name, module_id
+	);
+
+	/* draw the arrow */
+	dot_str_add(dot_str, "factory_%u -> module_%u [style=dashed];\n", g->id, module_id);
+}
+
+static void draw_module(struct global *g)
+{
+	spa_assert(g != NULL);
+	spa_assert(g->info != NULL);
+	spa_assert(g->type == INTERFACE_Module);
+
+	struct pw_module_info *info = g->info;
+	char **dot_str = &g->data->dot_str;
+
+	/* draw the box */
+	dot_str_add(dot_str, "module_%u [shape=box style=filled fillcolor=lightgrey];\n", g->id);
+
+	/* draw the label */
+	draw_label(dot_str,
+		"module", g->id, g->data->show_detail, info->props,
+		"module_id: %u\\lname: %s\\l",
+		g->id, info->name
+	);
+}
+
+static bool is_node_id_link_referenced(uint32_t id, struct spa_list *globals)
+{
+        struct global *g;
+        struct pw_link_info *info;
+        spa_list_for_each(g, globals, link) {
+                if (g->info == NULL)
+                        continue;
+                if (g->type != INTERFACE_Link)
+                        continue;
+                info = g->info;
+                if (info->input_node_id == id || info->output_node_id == id)
+                        return true;
+        }
+        return false;
+}
+
+static bool is_module_id_factory_referenced(uint32_t id, struct spa_list *globals)
+{
+        struct global *g;
+        struct pw_factory_info *info;
+        const char *module_id_str;
+        spa_list_for_each(g, globals, link) {
+                if (g->info == NULL)
+                        continue;
+                if (g->type != INTERFACE_Factory)
+                        continue;
+                info = g->info;
+                module_id_str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID);
+                if (module_id_str && (uint32_t)atoi(module_id_str) == id)
+                        return true;
+        }
+        return false;
+}
+
+static bool is_global_referenced(struct global *g)
+{
+	switch (g->type) {
+	case INTERFACE_Node:
+		return is_node_id_link_referenced(g->id, &g->data->globals);
+	case INTERFACE_Module:
+		return is_module_id_factory_referenced(g->id, &g->data->globals);
+	default:
+		break;
+	}
+
+	return true;
+}
+
+static int draw_graph(struct data *d, const char *path)
+{
+	FILE *fp;
+	struct global *g;
+
+	/* draw the header */
+	dot_str_add(&d->dot_str, "digraph pipewire {\n");
+
+	if (d->dot_rankdir) {
+		/* set rank direction, if provided */
+		dot_str_add(&d->dot_str, "rankdir = \"%s\";\n", d->dot_rankdir);
+	}
+
+	if (d->dot_orthoedges) {
+		/* enable orthogonal edges */
+		dot_str_add(&d->dot_str, "splines = ortho;\n");
+	}
+
+	/* iterate the globals */
+	spa_list_for_each(g, &d->globals, link) {
+		/* skip null and non-info globals */
+		if (g->info == NULL)
+			continue;
+
+		/* always skip ports since they are drawn by the nodes */
+		if (g->type == INTERFACE_Port)
+			continue;
+
+		/* skip clients, devices, factories and modules if all option is disabled */
+		if (!d->show_all) {
+			switch (g->type) {
+				case INTERFACE_Client:
+				case INTERFACE_Device:
+				case INTERFACE_Factory:
+				case INTERFACE_Module:
+					continue;
+				default:
+					break;
+			}
+		}
+
+		/* skip not referenced globals if smart option is enabled */
+		if (d->show_smart && !is_global_referenced(g))
+			continue;
+
+		/* draw the global */
+		if (g->draw)
+			g->draw(g);
+	}
+
+	/* draw the footer */
+	dot_str_add(&d->dot_str, "}\n");
+
+	if (spa_streq(path, "-")) {
+		/* wire the dot graph into to stdout */
+		fputs(d->dot_str, stdout);
+	} else {
+		/* open the file */
+		fp = fopen(path, "we");
+		if (fp == NULL) {
+			printf("open error: could not open %s for writing\n", path);
+			return -1;
+		}
+
+		/* wire the dot graph into the file */
+		fputs(d->dot_str, fp);
+		fclose(fp);
+	}
+	return 0;
+}
+
+static void global_event_info(struct global *g, const void *info)
+{
+        if (g->info_update)
+                g->info = g->info_update(g->info, info);
+}
+
+static void port_event_info(void *data, const struct pw_port_info *info)
+{
+        global_event_info(data, info);
+}
+
+static const struct pw_port_events port_events = {
+        PW_VERSION_PORT_EVENTS,
+        .info = port_event_info,
+};
+
+static void node_event_info(void *data, const struct pw_node_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_node_events node_events = {
+	PW_VERSION_NODE_EVENTS,
+	.info = node_event_info,
+};
+
+static void link_event_info(void *data, const struct pw_link_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_link_events link_events = {
+	PW_VERSION_LINK_EVENTS,
+	.info = link_event_info
+};
+
+static void client_event_info(void *data, const struct pw_client_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_client_events client_events = {
+	PW_VERSION_CLIENT_EVENTS,
+	.info = client_event_info
+};
+
+static void device_event_info(void *data, const struct pw_device_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_device_events device_events = {
+	PW_VERSION_DEVICE_EVENTS,
+	.info = device_event_info
+};
+
+static void factory_event_info(void *data, const struct pw_factory_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_factory_events factory_events = {
+	PW_VERSION_FACTORY_EVENTS,
+	.info = factory_event_info
+};
+
+static void module_event_info(void *data, const struct pw_module_info *info)
+{
+	global_event_info(data, info);
+}
+
+static const struct pw_module_events module_events = {
+	PW_VERSION_MODULE_EVENTS,
+	.info = module_event_info
+};
+
+static void removed_proxy(void *data)
+{
+	struct global *g = data;
+	pw_proxy_destroy(g->proxy);
+}
+
+static void destroy_proxy(void *data)
+{
+	struct global *g = data;
+	spa_hook_remove(&g->object_listener);
+	spa_hook_remove(&g->proxy_listener);
+}
+
+static const struct pw_proxy_events proxy_events = {
+	PW_VERSION_PROXY_EVENTS,
+	.removed = removed_proxy,
+	.destroy = destroy_proxy,
+};
+
+static void registry_event_global(void *data, uint32_t id, uint32_t permissions,
+				  const char *type, uint32_t version,
+				  const struct spa_dict *props)
+{
+        struct data *d = data;
+        struct pw_proxy *proxy;
+        uint32_t client_version;
+	uint32_t object_type;
+        const void *events;
+        pw_destroy_t info_destroy;
+        info_update_t info_update;
+        draw_t draw;
+        struct global *g;
+
+	if (spa_streq(type, PW_TYPE_INTERFACE_Port)) {
+		events = &port_events;
+		info_destroy = (pw_destroy_t)pw_port_info_free;
+		info_update = (info_update_t)pw_port_info_update;
+		draw = draw_port;
+		client_version = PW_VERSION_PORT;
+		object_type = INTERFACE_Port;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Node)) {
+		events = &node_events;
+		info_destroy = (pw_destroy_t)pw_node_info_free;
+		info_update = (info_update_t)pw_node_info_update;
+		draw = draw_node;
+		client_version = PW_VERSION_NODE;
+		object_type = INTERFACE_Node;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Link)) {
+		events = &link_events;
+		info_destroy = (pw_destroy_t)pw_link_info_free;
+		info_update = (info_update_t)pw_link_info_update;
+		draw = draw_link;
+		client_version = PW_VERSION_LINK;
+		object_type = INTERFACE_Link;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Client)) {
+		events = &client_events;
+		info_destroy = (pw_destroy_t)pw_client_info_free;
+		info_update = (info_update_t)pw_client_info_update;
+		draw = draw_client;
+		client_version = PW_VERSION_CLIENT;
+		object_type = INTERFACE_Client;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Device)) {
+		events = &device_events;
+		info_destroy = (pw_destroy_t)pw_device_info_free;
+		info_update = (info_update_t)pw_device_info_update;
+		draw = draw_device;
+		client_version = PW_VERSION_DEVICE;
+		object_type = INTERFACE_Device;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Factory)) {
+		events = &factory_events;
+		info_destroy = (pw_destroy_t)pw_factory_info_free;
+		info_update = (info_update_t)pw_factory_info_update;
+		draw = draw_factory;
+		client_version = PW_VERSION_FACTORY;
+		object_type = INTERFACE_Factory;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Module)) {
+		events = &module_events;
+		info_destroy = (pw_destroy_t)pw_module_info_free;
+		info_update = (info_update_t)pw_module_info_update;
+		draw = draw_module;
+		client_version = PW_VERSION_MODULE;
+		object_type = INTERFACE_Module;
+	}
+	else if (spa_streq(type, PW_TYPE_INTERFACE_Core)) {
+		/* sync to notify we are done with globals */
+		pw_core_sync(d->core, 0, 0);
+		return;
+	}
+	else {
+		return;
+	}
+
+	proxy = pw_registry_bind(d->registry, id, type, client_version, 0);
+	if (proxy == NULL)
+		return;
+
+	/* set the global data */
+	g = calloc(1, sizeof(struct global));
+	g->data = d;
+	g->proxy = proxy;
+
+	g->id = id;
+	g->type = object_type;
+	g->info = NULL;
+
+	g->info_destroy = info_destroy;
+	g->info_update = info_update;
+	g->draw = draw;
+
+        pw_proxy_add_object_listener(proxy, &g->object_listener, events, g);
+        pw_proxy_add_listener(proxy, &g->proxy_listener, &proxy_events, g);
+
+        /* add the global to the list */
+        spa_list_insert(&d->globals, &g->link);
+}
+
+static const struct pw_registry_events registry_events = {
+	PW_VERSION_REGISTRY_EVENTS,
+	.global = registry_event_global,
+};
+
+static void on_core_done(void *data, uint32_t id, int seq)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static void on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
+{
+	struct data *d = data;
+
+	pw_log_error("error id:%u seq:%d res:%d (%s): %s",
+			id, seq, res, spa_strerror(res), message);
+
+	if (id == PW_ID_CORE && res == -EPIPE)
+		pw_main_loop_quit(d->loop);
+}
+
+static const struct pw_core_events core_events = {
+	PW_VERSION_CORE_EVENTS,
+	.done = on_core_done,
+	.error = on_core_error,
+};
+
+static void do_quit(void *data, int signal_number)
+{
+	struct data *d = data;
+	pw_main_loop_quit(d->loop);
+}
+
+static int get_data_from_pipewire(struct data *data, const char *opt_remote)
+{
+	struct pw_loop *l;
+	struct global *g;
+
+	data->loop = pw_main_loop_new(NULL);
+	if (data->loop == NULL) {
+		fprintf(stderr, "can't create main loop: %m\n");
+		return -1;
+	}
+
+	l = pw_main_loop_get_loop(data->loop);
+	pw_loop_add_signal(l, SIGINT, do_quit, &data);
+	pw_loop_add_signal(l, SIGTERM, do_quit, &data);
+
+	data->context = pw_context_new(l, NULL, 0);
+	if (data->context == NULL) {
+		fprintf(stderr, "can't create context: %m\n");
+		pw_main_loop_destroy(data->loop);
+		return -1;
+	}
+
+	data->core = pw_context_connect(data->context,
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, opt_remote,
+				NULL),
+			0);
+	if (data->core == NULL) {
+		fprintf(stderr, "can't connect: %m\n");
+		pw_context_destroy(data->context);
+		pw_main_loop_destroy(data->loop);
+		return -1;
+	}
+
+	pw_core_add_listener(data->core,
+			     &data->core_listener,
+			     &core_events, data);
+
+	data->registry = pw_core_get_registry(data->core,
+					      PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(data->registry,
+				 &data->registry_listener,
+				 &registry_events, data);
+
+	pw_main_loop_run(data->loop);
+
+	spa_hook_remove(&data->registry_listener);
+	pw_proxy_destroy((struct pw_proxy*)data->registry);
+	spa_list_for_each(g, &data->globals, link)
+		pw_proxy_destroy(g->proxy);
+	spa_hook_remove(&data->core_listener);
+	pw_context_destroy(data->context);
+	pw_main_loop_destroy(data->loop);
+
+	return 0;
+}
+
+static void handle_json_obj(struct data *data, struct pw_properties *obj)
+{
+	struct global *g;
+	struct pw_properties *info, *props;
+	const char *str;
+
+	str = pw_properties_get(obj, "type");
+	if (!str) {
+		fprintf(stderr, "invalid object without type\n");
+		return;
+	}
+
+	g = calloc(1, sizeof (struct global));
+	g->data = data;
+
+	if (spa_streq(str, PW_TYPE_INTERFACE_Port)) {
+		g->info_destroy = (pw_destroy_t)pw_port_info_free;
+		g->draw = draw_port;
+		g->type = INTERFACE_Port;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Node)) {
+		g->info_destroy = (pw_destroy_t)pw_node_info_free;
+		g->draw = draw_node;
+		g->type = INTERFACE_Node;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Link)) {
+		g->info_destroy = (pw_destroy_t)pw_link_info_free;
+		g->draw = draw_link;
+		g->type = INTERFACE_Link;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Client)) {
+		g->info_destroy = (pw_destroy_t)pw_client_info_free;
+		g->draw = draw_client;
+		g->type = INTERFACE_Client;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Device)) {
+		g->info_destroy = (pw_destroy_t)pw_device_info_free;
+		g->draw = draw_device;
+		g->type = INTERFACE_Device;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Factory)) {
+		g->info_destroy = (pw_destroy_t)pw_factory_info_free;
+		g->draw = draw_factory;
+		g->type = INTERFACE_Factory;
+	}
+	else if (spa_streq(str, PW_TYPE_INTERFACE_Module)) {
+		g->info_destroy = (pw_destroy_t)pw_module_info_free;
+		g->draw = draw_module;
+		g->type = INTERFACE_Module;
+	}
+	else {
+		free(g);
+		return;
+	}
+
+	g->id = pw_properties_get_uint32(obj, "id", 0);
+
+	str = pw_properties_get(obj, "info");
+	info = pw_properties_new_string(str);
+
+	str = pw_properties_get(info, "props");
+	props = str ? pw_properties_new_string(str) : NULL;
+
+	switch (g->type) {
+		case INTERFACE_Port: {
+			struct pw_port_info pinfo = {0};
+			pinfo.id = g->id;
+			str = pw_properties_get(info, "direction");
+			pinfo.direction = spa_streq(str, "output") ?
+				PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT;
+			pinfo.props = props ? &props->dict : NULL;
+			pinfo.change_mask = PW_PORT_CHANGE_MASK_PROPS;
+			g->info = pw_port_info_update(NULL, &pinfo);
+			break;
+		}
+		case INTERFACE_Node: {
+			struct pw_node_info ninfo = {0};
+			ninfo.id = g->id;
+			ninfo.max_input_ports =
+				pw_properties_get_uint32(info, "max-input-ports", 0);
+			ninfo.max_output_ports =
+				pw_properties_get_uint32(info, "max-output-ports", 0);
+			ninfo.n_input_ports =
+				pw_properties_get_uint32(info, "n-input-ports", 0);
+			ninfo.n_output_ports =
+				pw_properties_get_uint32(info, "n-output-ports", 0);
+
+			str = pw_properties_get(info, "state");
+			if (spa_streq(str, "running"))
+				ninfo.state = PW_NODE_STATE_RUNNING;
+			else if (spa_streq(str, "idle"))
+				ninfo.state = PW_NODE_STATE_IDLE;
+			else if (spa_streq(str, "suspended"))
+				ninfo.state = PW_NODE_STATE_SUSPENDED;
+			else if (spa_streq(str, "creating"))
+				ninfo.state = PW_NODE_STATE_CREATING;
+			else
+				ninfo.state = PW_NODE_STATE_ERROR;
+			ninfo.error = pw_properties_get(info, "error");
+
+			ninfo.props = props ? &props->dict : NULL;
+			ninfo.change_mask = PW_NODE_CHANGE_MASK_INPUT_PORTS |
+					    PW_NODE_CHANGE_MASK_OUTPUT_PORTS |
+					    PW_NODE_CHANGE_MASK_STATE |
+					    PW_NODE_CHANGE_MASK_PROPS;
+			g->info = pw_node_info_update(NULL, &ninfo);
+			break;
+		}
+		case INTERFACE_Link: {
+			struct pw_link_info linfo = {0};
+			linfo.id = g->id;
+			linfo.output_node_id =
+				pw_properties_get_uint32(info, "output-node-id", 0);
+			linfo.output_port_id =
+				pw_properties_get_uint32(info, "output-port-id", 0);
+			linfo.input_node_id =
+				pw_properties_get_uint32(info, "input-node-id", 0);
+			linfo.input_port_id =
+				pw_properties_get_uint32(info, "input-port-id", 0);
+
+			str = pw_properties_get(info, "state");
+			if (spa_streq(str, "active"))
+				linfo.state = PW_LINK_STATE_ACTIVE;
+			else if (spa_streq(str, "paused"))
+				linfo.state = PW_LINK_STATE_PAUSED;
+			else if (spa_streq(str, "allocating"))
+				linfo.state = PW_LINK_STATE_ALLOCATING;
+			else if (spa_streq(str, "negotiating"))
+				linfo.state = PW_LINK_STATE_NEGOTIATING;
+			else if (spa_streq(str, "init"))
+				linfo.state = PW_LINK_STATE_INIT;
+			else if (spa_streq(str, "unlinked"))
+				linfo.state = PW_LINK_STATE_UNLINKED;
+			else
+				linfo.state = PW_LINK_STATE_ERROR;
+			linfo.error = pw_properties_get(info, "error");
+
+			linfo.props = props ? &props->dict : NULL;
+			linfo.change_mask = PW_LINK_CHANGE_MASK_STATE |
+					    PW_LINK_CHANGE_MASK_PROPS;
+			g->info = pw_link_info_update(NULL, &linfo);
+			break;
+		}
+		case INTERFACE_Client: {
+			struct pw_client_info cinfo = {0};
+			cinfo.id = g->id;
+			cinfo.props = props ? &props->dict : NULL;
+			cinfo.change_mask = PW_CLIENT_CHANGE_MASK_PROPS;
+			g->info = pw_client_info_update(NULL, &cinfo);
+			break;
+		}
+		case INTERFACE_Device: {
+			struct pw_device_info dinfo = {0};
+			dinfo.id = g->id;
+			dinfo.props = props ? &props->dict : NULL;
+			dinfo.change_mask = PW_DEVICE_CHANGE_MASK_PROPS;
+			g->info = pw_device_info_update(NULL, &dinfo);
+			break;
+		}
+		case INTERFACE_Factory: {
+			struct pw_factory_info finfo = {0};
+			finfo.id = g->id;
+			finfo.name = pw_properties_get(info, "name");
+			finfo.type = pw_properties_get(info, "type");
+			finfo.version = pw_properties_get_uint32(info, "version", 0);
+			finfo.props = props ? &props->dict : NULL;
+			finfo.change_mask = PW_FACTORY_CHANGE_MASK_PROPS;
+			g->info = pw_factory_info_update(NULL, &finfo);
+			break;
+		}
+		case INTERFACE_Module: {
+			struct pw_module_info minfo = {0};
+			minfo.id = g->id;
+			minfo.name = pw_properties_get(info, "name");
+			minfo.filename = pw_properties_get(info, "filename");
+			minfo.args = pw_properties_get(info, "args");
+			minfo.props = props ? &props->dict : NULL;
+			minfo.change_mask = PW_MODULE_CHANGE_MASK_PROPS;
+			g->info = pw_module_info_update(NULL, &minfo);
+			break;
+		}
+		default:
+			break;
+	}
+
+	pw_properties_free(info);
+	pw_properties_free(props);
+
+	/* add the global to the list */
+	spa_list_insert(&data->globals, &g->link);
+}
+
+static int get_data_from_json(struct data *data, const char *json_path)
+{
+	int fd, len;
+	void *json;
+	struct stat sbuf;
+	struct spa_json it[2];
+	const char *value;
+
+	if ((fd = open(json_path,  O_CLOEXEC | O_RDONLY)) < 0) {
+		fprintf(stderr, "error opening file '%s': %m\n", json_path);
+		return -1;
+	}
+	if (fstat(fd, &sbuf) < 0) {
+		fprintf(stderr, "error statting file '%s': %m\n", json_path);
+		close(fd);
+		return -1;
+	}
+	if ((json = mmap(NULL, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) {
+		fprintf(stderr, "error mmapping file '%s': %m\n", json_path);
+		close(fd);
+		return -1;
+	}
+
+	close(fd);
+	spa_json_init(&it[0], json, sbuf.st_size);
+
+	if (spa_json_enter_array(&it[0], &it[1]) <= 0) {
+		fprintf(stderr, "expected top-level array in JSON file '%s'\n", json_path);
+		munmap(json, sbuf.st_size);
+		return -1;
+	}
+
+	while ((len = spa_json_next(&it[1], &value)) > 0 && spa_json_is_object(value, len)) {
+		struct pw_properties *obj;
+		obj = pw_properties_new(NULL, NULL);
+		len = spa_json_container_len(&it[1], value, len);
+		pw_properties_update_string(obj, value, len);
+		handle_json_obj(data, obj);
+		pw_properties_free(obj);
+	}
+
+	munmap(json, sbuf.st_size);
+	return 0;
+}
+
+static void show_help(const char *name, bool error)
+{
+        fprintf(error ? stderr : stdout, "%s [options]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -a, --all                             Show all object types\n"
+		"  -s, --smart                           Show linked objects only\n"
+		"  -d, --detail                          Show all object properties\n"
+		"  -r, --remote                          Remote daemon name\n"
+		"  -o, --output                          Output file (Default %s)\n"
+		"  -L, --lr                              Use left-right rank direction\n"
+		"  -9, --90                              Use orthogonal edges\n"
+		"  -j, --json                            Read objects from pw-dump JSON file\n",
+		name,
+		DEFAULT_DOT_PATH);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0 };
+	struct global *g;
+	const char *opt_remote = NULL;
+	const char *dot_path = DEFAULT_DOT_PATH;
+	const char *json_path = NULL;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "all",	no_argument,		NULL, 'a' },
+		{ "smart",	no_argument,		NULL, 's' },
+		{ "detail",	no_argument,		NULL, 'd' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ "output",	required_argument,	NULL, 'o' },
+		{ "lr",		no_argument,		NULL, 'L' },
+		{ "90",		no_argument,		NULL, '9' },
+		{ "json",	required_argument,	NULL, 'j' },
+		{ NULL, 0, NULL, 0}
+	};
+	int c;
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	while ((c = getopt_long(argc, argv, "hVasdr:o:L9j:", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h' :
+			show_help(argv[0], false);
+			return 0;
+		case 'V' :
+			printf("%s\n"
+				"Compiled with libpipewire %s\n"
+				"Linked with libpipewire %s\n",
+				argv[0],
+				pw_get_headers_version(),
+				pw_get_library_version());
+			return 0;
+		case 'a' :
+			data.show_all = true;
+			fprintf(stderr, "all option enabled\n");
+			break;
+		case 's' :
+			data.show_smart = true;
+			fprintf(stderr, "smart option enabled\n");
+			break;
+		case 'd' :
+			data.show_detail = true;
+			fprintf(stderr, "detail option enabled\n");
+			break;
+		case 'r' :
+			opt_remote = optarg;
+			fprintf(stderr, "set remote to %s\n", opt_remote);
+			break;
+		case 'o' :
+			dot_path = optarg;
+			fprintf(stderr, "set output file %s\n", dot_path);
+			break;
+		case 'L' :
+			data.dot_rankdir = "LR";
+			fprintf(stderr, "set rank direction to LR\n");
+			break;
+		case '9' :
+			data.dot_orthoedges = true;
+			fprintf(stderr, "orthogonal edges enabled\n");
+			break;
+		case 'j' :
+			json_path = optarg;
+			fprintf(stderr, "Using JSON file %s as input\n", json_path);
+			break;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+
+	if (!(data.dot_str = dot_str_new()))
+		return -1;
+
+	spa_list_init(&data.globals);
+
+	if (!json_path && get_data_from_pipewire(&data, opt_remote) < 0)
+		return -1;
+	else if (json_path && get_data_from_json(&data, json_path) < 0)
+		return -1;
+
+	draw_graph(&data, dot_path);
+
+	dot_str_clear(&data.dot_str);
+	spa_list_consume(g, &data.globals, link) {
+		if (g->info && g->info_destroy)
+			g->info_destroy(g->info);
+		spa_list_remove(&g->link);
+		free(g);
+	}
+	pw_deinit();
+
+	return 0;
+}