Adding upstream version 0.3.65.upstream/0.3.65upstream

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

1 files changed, 1259 insertions, 0 deletions

diff --git a/src/modules/module-client-node/protocol-native.c b/src/modules/module-client-node/protocol-native.c
new file mode 100644
index 0000000..dd51692
--- /dev/null
+++ b/src/modules/module-client-node/protocol-native.c
@@ -0,0 +1,1259 @@
+/* PipeWire
+ *
+ * Copyright © 2018 Wim Taymans
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <errno.h>
+
+#include <spa/pod/builder.h>
+#include <spa/pod/parser.h>
+#include <spa/utils/result.h>
+
+#include <pipewire/impl.h>
+
+#include <pipewire/extensions/protocol-native.h>
+#include <pipewire/extensions/client-node.h>
+
+#define MAX_DICT	1024
+#define MAX_PARAMS	4096
+#define MAX_PARAM_INFO	128
+#define MAX_BUFFERS	64
+#define MAX_METAS	16u
+#define MAX_DATAS	64u
+
+PW_LOG_TOPIC_EXTERN(mod_topic);
+#define PW_LOG_TOPIC_DEFAULT mod_topic
+
+static inline void push_item(struct spa_pod_builder *b, const struct spa_dict_item *item)
+{
+	const char *str;
+	spa_pod_builder_string(b, item->key);
+	str = item->value;
+	if (spa_strstartswith(str, "pointer:"))
+		str = "";
+	spa_pod_builder_string(b, str);
+}
+
+static void push_dict(struct spa_pod_builder *b, const struct spa_dict *dict)
+{
+	uint32_t i, n_items;
+	struct spa_pod_frame f;
+
+	n_items = dict ? dict->n_items : 0;
+
+	spa_pod_builder_push_struct(b, &f);
+	spa_pod_builder_int(b, n_items);
+	for (i = 0; i < n_items; i++)
+		push_item(b, &dict->items[i]);
+	spa_pod_builder_pop(b, &f);
+}
+
+static inline int parse_item(struct spa_pod_parser *prs, struct spa_dict_item *item)
+{
+	int res;
+	if ((res = spa_pod_parser_get(prs,
+		       SPA_POD_String(&item->key),
+		       SPA_POD_String(&item->value),
+		       NULL)) < 0)
+		return res;
+	if (spa_strstartswith(item->value, "pointer:"))
+		item->value = "";
+	return 0;
+}
+
+#define parse_dict(prs,d)								\
+do {											\
+	uint32_t i;									\
+	if (spa_pod_parser_get(prs,							\
+			 SPA_POD_Int(&(d)->n_items), NULL) < 0)				\
+		return -EINVAL;								\
+	(d)->items = NULL;								\
+	if ((d)->n_items > 0) {								\
+		if ((d)->n_items > MAX_DICT) 						\
+			return -ENOSPC;							\
+		(d)->items = alloca((d)->n_items * sizeof(struct spa_dict_item));	\
+		for (i = 0; i < (d)->n_items; i++) {					\
+			if (parse_item(prs, (struct spa_dict_item *) &(d)->items[i]) < 0)	\
+				return -EINVAL;						\
+		}									\
+	}										\
+} while(0)
+
+#define parse_dict_struct(prs,f,dict)						\
+do {										\
+	if (spa_pod_parser_push_struct(prs, f) < 0)				\
+		return -EINVAL;							\
+	parse_dict(prs, dict);							\
+	spa_pod_parser_pop(prs, f);						\
+} while(0)
+
+#define parse_params(prs,n_params,params)						\
+do {											\
+	uint32_t i;									\
+	if (spa_pod_parser_get(prs,							\
+			 SPA_POD_Int(&n_params), NULL) < 0)				\
+		return -EINVAL;								\
+	params = NULL;									\
+	if (n_params > 0) {								\
+		if (n_params > MAX_PARAMS)						\
+			return -ENOSPC;							\
+		params = alloca(n_params * sizeof(struct spa_pod *));			\
+		for (i = 0; i < n_params; i++) {					\
+			if (spa_pod_parser_get(prs,					\
+					SPA_POD_PodObject(&params[i]), NULL) < 0)	\
+				return -EINVAL;						\
+		}									\
+	}										\
+} while(0)
+
+#define parse_param_info(prs,n_params,params)						\
+do {											\
+	uint32_t i;									\
+	if (spa_pod_parser_get(prs,							\
+			SPA_POD_Int(&(n_params)), NULL) < 0)				\
+		return -EINVAL;								\
+	params = NULL;									\
+	if (n_params > 0) {								\
+		if (n_params > MAX_PARAM_INFO)						\
+			return -ENOSPC;							\
+		params = alloca(n_params * sizeof(struct spa_param_info));		\
+		for (i = 0; i < n_params; i++) {					\
+			if (spa_pod_parser_get(prs,					\
+					SPA_POD_Id(&(params[i]).id),			\
+					SPA_POD_Int(&(params[i]).flags), NULL) < 0)	\
+				return -EINVAL;						\
+		}									\
+	}										\
+} while(0)
+
+static int client_node_marshal_add_listener(void *object,
+			struct spa_hook *listener,
+			const struct pw_client_node_events *events,
+			void *data)
+{
+	struct pw_proxy *proxy = object;
+	pw_proxy_add_object_listener(proxy, listener, events, data);
+	return 0;
+}
+
+static struct pw_node *
+client_node_marshal_get_node(void *object, uint32_t version, size_t user_data_size)
+{
+	struct pw_proxy *proxy = object;
+	struct spa_pod_builder *b;
+	struct pw_proxy *res;
+	uint32_t new_id;
+
+	res = pw_proxy_new(object, PW_TYPE_INTERFACE_Node, version, user_data_size);
+	if (res == NULL)
+		return NULL;
+
+	new_id = pw_proxy_get_id(res);
+
+	b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_METHOD_GET_NODE, NULL);
+
+	spa_pod_builder_add_struct(b,
+		       SPA_POD_Int(version),
+		       SPA_POD_Int(new_id));
+
+	pw_protocol_native_end_proxy(proxy, b);
+
+	return (struct pw_node *) res;
+}
+
+static int
+client_node_marshal_update(void *object,
+			   uint32_t change_mask,
+			   uint32_t n_params,
+			   const struct spa_pod **params,
+			   const struct spa_node_info *info)
+{
+	struct pw_proxy *proxy = object;
+	struct spa_pod_builder *b;
+	struct spa_pod_frame f[2];
+	uint32_t i, n_items, n_info_params;
+
+	b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_METHOD_UPDATE, NULL);
+
+	spa_pod_builder_push_struct(b, &f[0]);
+	spa_pod_builder_add(b,
+			SPA_POD_Int(change_mask),
+			SPA_POD_Int(n_params), NULL);
+
+	for (i = 0; i < n_params; i++)
+		spa_pod_builder_add(b, SPA_POD_Pod(params[i]), NULL);
+
+	if (info) {
+		uint64_t change_mask = info->change_mask;
+
+		change_mask &= SPA_NODE_CHANGE_MASK_FLAGS |
+				SPA_NODE_CHANGE_MASK_PROPS |
+				SPA_NODE_CHANGE_MASK_PARAMS;
+
+		n_items = info->props && (change_mask & SPA_NODE_CHANGE_MASK_PROPS) ?
+			info->props->n_items : 0;
+		n_info_params = (change_mask & SPA_NODE_CHANGE_MASK_PARAMS) ?
+			info->n_params : 0;
+
+		spa_pod_builder_push_struct(b, &f[1]);
+		spa_pod_builder_add(b,
+				    SPA_POD_Int(info->max_input_ports),
+				    SPA_POD_Int(info->max_output_ports),
+				    SPA_POD_Long(change_mask),
+				    SPA_POD_Long(info->flags),
+				    SPA_POD_Int(n_items), NULL);
+		for (i = 0; i < n_items; i++)
+			push_item(b, &info->props->items[i]);
+		spa_pod_builder_add(b,
+				    SPA_POD_Int(n_info_params), NULL);
+		for (i = 0; i < n_info_params; i++) {
+			spa_pod_builder_add(b,
+					    SPA_POD_Id(info->params[i].id),
+					    SPA_POD_Int(info->params[i].flags), NULL);
+		}
+		spa_pod_builder_pop(b, &f[1]);
+
+	} else {
+		spa_pod_builder_add(b,
+				SPA_POD_Pod(NULL), NULL);
+	}
+	spa_pod_builder_pop(b, &f[0]);
+
+	return pw_protocol_native_end_proxy(proxy, b);
+}
+
+static int
+client_node_marshal_port_update(void *object,
+				enum spa_direction direction,
+				uint32_t port_id,
+				uint32_t change_mask,
+				uint32_t n_params,
+				const struct spa_pod **params,
+				const struct spa_port_info *info)
+{
+	struct pw_proxy *proxy = object;
+	struct spa_pod_builder *b;
+	struct spa_pod_frame f[2];
+	uint32_t i, n_items;
+
+	b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_METHOD_PORT_UPDATE, NULL);
+
+	spa_pod_builder_push_struct(b, &f[0]);
+	spa_pod_builder_add(b,
+			    SPA_POD_Int(direction),
+			    SPA_POD_Int(port_id),
+			    SPA_POD_Int(change_mask),
+			    SPA_POD_Int(n_params), NULL);
+
+	for (i = 0; i < n_params; i++)
+		spa_pod_builder_add(b,
+				SPA_POD_Pod(params[i]), NULL);
+
+	if (info) {
+		uint64_t change_mask = info->change_mask;
+
+		n_items = info->props ? info->props->n_items : 0;
+
+		change_mask &= SPA_PORT_CHANGE_MASK_FLAGS |
+				SPA_PORT_CHANGE_MASK_RATE |
+				SPA_PORT_CHANGE_MASK_PROPS |
+				SPA_PORT_CHANGE_MASK_PARAMS;
+
+		spa_pod_builder_push_struct(b, &f[1]);
+		spa_pod_builder_add(b,
+				    SPA_POD_Long(change_mask),
+				    SPA_POD_Long(info->flags),
+				    SPA_POD_Int(info->rate.num),
+				    SPA_POD_Int(info->rate.denom),
+				    SPA_POD_Int(n_items), NULL);
+		for (i = 0; i < n_items; i++)
+			push_item(b, &info->props->items[i]);
+		spa_pod_builder_add(b,
+				    SPA_POD_Int(info->n_params), NULL);
+		for (i = 0; i < info->n_params; i++) {
+			spa_pod_builder_add(b,
+					    SPA_POD_Id(info->params[i].id),
+					    SPA_POD_Int(info->params[i].flags), NULL);
+		}
+		spa_pod_builder_pop(b, &f[1]);
+
+	} else {
+		spa_pod_builder_add(b,
+				SPA_POD_Pod(NULL), NULL);
+	}
+	spa_pod_builder_pop(b, &f[0]);
+
+	return pw_protocol_native_end_proxy(proxy, b);
+}
+
+static int client_node_marshal_set_active(void *object, bool active)
+{
+	struct pw_proxy *proxy = object;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_METHOD_SET_ACTIVE, NULL);
+
+	spa_pod_builder_add_struct(b,
+			SPA_POD_Bool(active));
+
+	return pw_protocol_native_end_proxy(proxy, b);
+}
+
+static int client_node_marshal_event_method(void *object, const struct spa_event *event)
+{
+	struct pw_proxy *proxy = object;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_METHOD_EVENT, NULL);
+
+	spa_pod_builder_add_struct(b,
+			SPA_POD_Pod(event));
+
+	return pw_protocol_native_end_proxy(proxy, b);
+}
+
+static int
+client_node_marshal_port_buffers(void *object,
+				enum spa_direction direction,
+				uint32_t port_id,
+				uint32_t mix_id,
+				uint32_t n_buffers,
+				struct spa_buffer **buffers)
+{
+	struct pw_proxy *proxy = object;
+	struct spa_pod_builder *b;
+	struct spa_pod_frame f[2];
+	uint32_t i, j;
+
+	b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_METHOD_PORT_BUFFERS, NULL);
+
+	spa_pod_builder_push_struct(b, &f[0]);
+	spa_pod_builder_add(b,
+			    SPA_POD_Int(direction),
+			    SPA_POD_Int(port_id),
+			    SPA_POD_Int(mix_id),
+			    SPA_POD_Int(n_buffers), NULL);
+
+	for (i = 0; i < n_buffers; i++) {
+		struct spa_buffer *buf = buffers[i];
+
+		spa_pod_builder_add(b,
+				SPA_POD_Int(buf->n_datas), NULL);
+
+		for (j = 0; j < buf->n_datas; j++) {
+			struct spa_data *d = &buf->datas[j];
+			spa_pod_builder_add(b,
+					SPA_POD_Id(d->type),
+					SPA_POD_Fd(pw_protocol_native_add_proxy_fd(proxy, d->fd)),
+					SPA_POD_Int(d->flags),
+					SPA_POD_Int(d->mapoffset),
+					SPA_POD_Int(d->maxsize), NULL);
+		}
+	}
+	spa_pod_builder_pop(b, &f[0]);
+
+	return pw_protocol_native_end_proxy(proxy, b);
+}
+
+static int client_node_demarshal_transport(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	uint32_t mem_id, offset, sz;
+	int64_t ridx, widx;
+	int readfd, writefd;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_Fd(&ridx),
+			SPA_POD_Fd(&widx),
+			SPA_POD_Int(&mem_id),
+			SPA_POD_Int(&offset),
+			SPA_POD_Int(&sz)) < 0)
+		return -EINVAL;
+
+	readfd = pw_protocol_native_get_proxy_fd(proxy, ridx);
+	writefd = pw_protocol_native_get_proxy_fd(proxy, widx);
+
+	if (readfd < 0 || writefd < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, transport, 0,
+								   readfd, writefd, mem_id,
+								   offset, sz);
+	return 0;
+}
+
+static int client_node_demarshal_set_param(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	uint32_t id, flags;
+	const struct spa_pod *param = NULL;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_Id(&id),
+			SPA_POD_Int(&flags),
+			SPA_POD_PodObject(&param)) < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, set_param, 0, id, flags, param);
+	return 0;
+}
+
+static int client_node_demarshal_event_event(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	const struct spa_event *event;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+				SPA_POD_PodObject(&event)) < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, event, 0, event);
+	return 0;
+}
+
+static int client_node_demarshal_command(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	const struct spa_command *command;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_PodObject(&command)) < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, command, 0, command);
+	return 0;
+}
+
+static int client_node_demarshal_add_port(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	struct spa_pod_frame f[2];
+	int32_t direction, port_id;
+	struct spa_dict props = SPA_DICT_INIT(NULL, 0);
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_push_struct(&prs, &f[0]) < 0)
+		return -EINVAL;
+
+	if (spa_pod_parser_get(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id), NULL) < 0)
+		return -EINVAL;
+
+	parse_dict_struct(&prs, &f[1], &props);
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, add_port, 0, direction, port_id,
+			props.n_items ? &props : NULL);
+	return 0;
+}
+
+static int client_node_demarshal_remove_port(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	int32_t direction, port_id;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id)) < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, remove_port, 0, direction, port_id);
+	return 0;
+}
+
+static int client_node_demarshal_port_set_param(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	uint32_t direction, port_id, id, flags;
+	const struct spa_pod *param = NULL;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id),
+			SPA_POD_Id(&id),
+			SPA_POD_Int(&flags),
+			SPA_POD_PodObject(&param)) < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, port_set_param, 0,
+			direction, port_id, id, flags, param);
+	return 0;
+}
+
+static int client_node_demarshal_port_use_buffers(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	struct spa_pod_frame f;
+	uint32_t direction, port_id, mix_id, flags, n_buffers, data_id;
+	struct pw_client_node_buffer *buffers;
+	uint32_t i, j;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_push_struct(&prs, &f) < 0 ||
+	    spa_pod_parser_get(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id),
+			SPA_POD_Int(&mix_id),
+			SPA_POD_Int(&flags),
+			SPA_POD_Int(&n_buffers), NULL) < 0)
+		return -EINVAL;
+
+	if (n_buffers > MAX_BUFFERS)
+		return -ENOSPC;
+
+	buffers = alloca(sizeof(struct pw_client_node_buffer) * n_buffers);
+	for (i = 0; i < n_buffers; i++) {
+		struct spa_buffer *buf = buffers[i].buffer = alloca(sizeof(struct spa_buffer));
+
+		if (spa_pod_parser_get(&prs,
+				      SPA_POD_Int(&buffers[i].mem_id),
+				      SPA_POD_Int(&buffers[i].offset),
+				      SPA_POD_Int(&buffers[i].size),
+				      SPA_POD_Int(&buf->n_metas), NULL) < 0)
+			return -EINVAL;
+
+		if (buf->n_metas > MAX_METAS)
+			return -ENOSPC;
+
+		buf->metas = alloca(sizeof(struct spa_meta) * buf->n_metas);
+		for (j = 0; j < buf->n_metas; j++) {
+			struct spa_meta *m = &buf->metas[j];
+
+			if (spa_pod_parser_get(&prs,
+					      SPA_POD_Id(&m->type),
+					      SPA_POD_Int(&m->size), NULL) < 0)
+				return -EINVAL;
+
+			m->data = NULL;
+		}
+		if (spa_pod_parser_get(&prs,
+					SPA_POD_Int(&buf->n_datas), NULL) < 0)
+			return -EINVAL;
+
+		if (buf->n_datas > MAX_DATAS)
+			return -ENOSPC;
+
+		buf->datas = alloca(sizeof(struct spa_data) * buf->n_datas);
+		for (j = 0; j < buf->n_datas; j++) {
+			struct spa_data *d = &buf->datas[j];
+
+			if (spa_pod_parser_get(&prs,
+					      SPA_POD_Id(&d->type),
+					      SPA_POD_Int(&data_id),
+					      SPA_POD_Int(&d->flags),
+					      SPA_POD_Int(&d->mapoffset),
+					      SPA_POD_Int(&d->maxsize), NULL) < 0)
+				return -EINVAL;
+
+			d->fd = -1;
+			d->data = SPA_UINT32_TO_PTR(data_id);
+			d->chunk = NULL;
+		}
+	}
+	pw_proxy_notify(proxy, struct pw_client_node_events, port_use_buffers, 0,
+									  direction,
+									  port_id,
+									  mix_id,
+									  flags,
+									  n_buffers, buffers);
+	return 0;
+}
+
+static int client_node_demarshal_port_set_io(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	uint32_t direction, port_id, mix_id, id, memid, off, sz;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id),
+			SPA_POD_Int(&mix_id),
+			SPA_POD_Id(&id),
+			SPA_POD_Int(&memid),
+			SPA_POD_Int(&off),
+			SPA_POD_Int(&sz)) < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, port_set_io, 0,
+							direction, port_id, mix_id,
+							id, memid,
+							off, sz);
+	return 0;
+}
+
+static int client_node_demarshal_set_activation(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	uint32_t node_id, memid, off, sz;
+	int64_t sigidx;
+	int signalfd;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_Int(&node_id),
+			SPA_POD_Fd(&sigidx),
+			SPA_POD_Int(&memid),
+			SPA_POD_Int(&off),
+			SPA_POD_Int(&sz)) < 0)
+		return -EINVAL;
+
+	signalfd = pw_protocol_native_get_proxy_fd(proxy, sigidx);
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, set_activation, 0,
+							node_id,
+							signalfd,
+							memid,
+							off, sz);
+	return 0;
+}
+
+static int client_node_demarshal_port_set_mix_info(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	uint32_t direction, port_id, mix_id, peer_id;
+	struct spa_pod_frame f[2];
+	struct spa_dict props = SPA_DICT_INIT(NULL, 0);
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
+	    spa_pod_parser_get(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id),
+			SPA_POD_Int(&mix_id),
+			SPA_POD_Int(&peer_id), NULL) < 0)
+		return -EINVAL;
+
+	parse_dict_struct(&prs, &f[1], &props);
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, port_set_mix_info, 1,
+							direction, port_id, mix_id,
+							peer_id, &props);
+	return 0;
+}
+
+static int client_node_demarshal_set_io(void *data, const struct pw_protocol_native_message *msg)
+{
+	struct pw_proxy *proxy = data;
+	struct spa_pod_parser prs;
+	uint32_t id, memid, off, sz;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_Id(&id),
+			SPA_POD_Int(&memid),
+			SPA_POD_Int(&off),
+			SPA_POD_Int(&sz)) < 0)
+		return -EINVAL;
+
+	pw_proxy_notify(proxy, struct pw_client_node_events, set_io, 0,
+			id, memid, off, sz);
+	return 0;
+}
+
+static int client_node_marshal_transport(void *data, int readfd, int writefd,
+		uint32_t mem_id, uint32_t offset, uint32_t size)
+{
+	struct pw_protocol_native_message *msg;
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_TRANSPORT, &msg);
+
+	spa_pod_builder_add_struct(b,
+			       SPA_POD_Fd(pw_protocol_native_add_resource_fd(resource, readfd)),
+			       SPA_POD_Fd(pw_protocol_native_add_resource_fd(resource, writefd)),
+			       SPA_POD_Int(mem_id),
+			       SPA_POD_Int(offset),
+			       SPA_POD_Int(size));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_set_param(void *data, uint32_t id, uint32_t flags,
+			      const struct spa_pod *param)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_SET_PARAM, NULL);
+
+	spa_pod_builder_add_struct(b,
+			       SPA_POD_Id(id),
+			       SPA_POD_Int(flags),
+			       SPA_POD_Pod(param));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int client_node_marshal_event_event(void *data, const struct spa_event *event)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_EVENT, NULL);
+
+	spa_pod_builder_add_struct(b,
+			SPA_POD_Pod(event));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_command(void *data, const struct spa_command *command)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_COMMAND, NULL);
+
+	spa_pod_builder_add_struct(b,
+			SPA_POD_Pod(command));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_add_port(void *data,
+			     enum spa_direction direction, uint32_t port_id,
+			     const struct spa_dict *props)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+	struct spa_pod_frame f;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_ADD_PORT, NULL);
+
+	spa_pod_builder_push_struct(b, &f);
+	spa_pod_builder_add(b,
+			SPA_POD_Int(direction),
+			SPA_POD_Int(port_id), NULL);
+	push_dict(b, props);
+	spa_pod_builder_pop(b, &f);
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_remove_port(void *data,
+				enum spa_direction direction, uint32_t port_id)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_REMOVE_PORT, NULL);
+
+	spa_pod_builder_add_struct(b,
+			       SPA_POD_Int(direction),
+			       SPA_POD_Int(port_id));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_port_set_param(void *data,
+				   enum spa_direction direction,
+				   uint32_t port_id,
+				   uint32_t id,
+				   uint32_t flags,
+				   const struct spa_pod *param)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_PORT_SET_PARAM, NULL);
+
+	spa_pod_builder_add_struct(b,
+			       SPA_POD_Int(direction),
+			       SPA_POD_Int(port_id),
+			       SPA_POD_Id(id),
+			       SPA_POD_Int(flags),
+			       SPA_POD_Pod(param));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_port_use_buffers(void *data,
+				     enum spa_direction direction,
+				     uint32_t port_id,
+				     uint32_t mix_id,
+				     uint32_t flags,
+				     uint32_t n_buffers, struct pw_client_node_buffer *buffers)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+	struct spa_pod_frame f;
+	uint32_t i, j;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_PORT_USE_BUFFERS, NULL);
+
+	spa_pod_builder_push_struct(b, &f);
+	spa_pod_builder_add(b,
+			SPA_POD_Int(direction),
+			SPA_POD_Int(port_id),
+			SPA_POD_Int(mix_id),
+			SPA_POD_Int(flags),
+			SPA_POD_Int(n_buffers), NULL);
+
+	for (i = 0; i < n_buffers; i++) {
+		struct spa_buffer *buf = buffers[i].buffer;
+
+		spa_pod_builder_add(b,
+				    SPA_POD_Int(buffers[i].mem_id),
+				    SPA_POD_Int(buffers[i].offset),
+				    SPA_POD_Int(buffers[i].size),
+				    SPA_POD_Int(buf->n_metas), NULL);
+
+		for (j = 0; j < buf->n_metas; j++) {
+			struct spa_meta *m = &buf->metas[j];
+			spa_pod_builder_add(b,
+					    SPA_POD_Id(m->type),
+					    SPA_POD_Int(m->size), NULL);
+		}
+		spa_pod_builder_add(b,
+				SPA_POD_Int(buf->n_datas), NULL);
+		for (j = 0; j < buf->n_datas; j++) {
+			struct spa_data *d = &buf->datas[j];
+			spa_pod_builder_add(b,
+					    SPA_POD_Id(d->type),
+					    SPA_POD_Int(SPA_PTR_TO_UINT32(d->data)),
+					    SPA_POD_Int(d->flags),
+					    SPA_POD_Int(d->mapoffset),
+					    SPA_POD_Int(d->maxsize), NULL);
+		}
+	}
+	spa_pod_builder_pop(b, &f);
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_port_set_io(void *data,
+				uint32_t direction,
+				uint32_t port_id,
+				uint32_t mix_id,
+				uint32_t id,
+				uint32_t memid,
+				uint32_t offset,
+				uint32_t size)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_PORT_SET_IO, NULL);
+
+	spa_pod_builder_add_struct(b,
+			       SPA_POD_Int(direction),
+			       SPA_POD_Int(port_id),
+			       SPA_POD_Int(mix_id),
+			       SPA_POD_Id(id),
+			       SPA_POD_Int(memid),
+			       SPA_POD_Int(offset),
+			       SPA_POD_Int(size));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_set_activation(void *data,
+				uint32_t node_id,
+				int signalfd,
+				uint32_t memid,
+				uint32_t offset,
+				uint32_t size)
+{
+	struct pw_protocol_native_message *msg;
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_SET_ACTIVATION, &msg);
+
+	spa_pod_builder_add_struct(b,
+			       SPA_POD_Int(node_id),
+			       SPA_POD_Fd(pw_protocol_native_add_resource_fd(resource, signalfd)),
+			       SPA_POD_Int(memid),
+			       SPA_POD_Int(offset),
+			       SPA_POD_Int(size));
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_set_io(void *data,
+			   uint32_t id,
+			   uint32_t memid,
+			   uint32_t offset,
+			   uint32_t size)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_SET_IO, NULL);
+	spa_pod_builder_add_struct(b,
+			       SPA_POD_Id(id),
+			       SPA_POD_Int(memid),
+			       SPA_POD_Int(offset),
+			       SPA_POD_Int(size));
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+static int
+client_node_marshal_port_set_mix_info(void *data,
+				uint32_t direction,
+				uint32_t port_id,
+				uint32_t mix_id,
+				uint32_t peer_id,
+				const struct spa_dict *props)
+{
+	struct pw_resource *resource = data;
+	struct spa_pod_builder *b;
+	struct spa_pod_frame f;
+
+	b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_EVENT_PORT_SET_MIX_INFO, NULL);
+
+	spa_pod_builder_push_struct(b, &f);
+	spa_pod_builder_add(b,
+			SPA_POD_Int(direction),
+			SPA_POD_Int(port_id),
+			SPA_POD_Int(mix_id),
+			SPA_POD_Int(peer_id), NULL);
+	push_dict(b, props);
+	spa_pod_builder_pop(b, &f);
+
+	return pw_protocol_native_end_resource(resource, b);
+}
+
+
+static int client_node_demarshal_get_node(void *object, const struct pw_protocol_native_message *msg)
+{
+	struct pw_resource *resource = object;
+	struct spa_pod_parser prs;
+	int32_t version, new_id;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+				SPA_POD_Int(&version),
+				SPA_POD_Int(&new_id)) < 0)
+		return -EINVAL;
+
+	return pw_resource_notify(resource, struct pw_client_node_methods, get_node, 0,
+			version, new_id);
+}
+
+static int client_node_demarshal_update(void *object, const struct pw_protocol_native_message *msg)
+{
+	struct pw_resource *resource = object;
+	struct spa_pod_parser prs;
+	struct spa_pod_frame f[2];
+	uint32_t change_mask, n_params;
+	const struct spa_pod **params = NULL;
+	struct spa_node_info info = SPA_NODE_INFO_INIT(), *infop = NULL;
+	struct spa_pod *ipod;
+	struct spa_dict props = SPA_DICT_INIT(NULL, 0);
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
+	    spa_pod_parser_get(&prs,
+			SPA_POD_Int(&change_mask), NULL) < 0)
+		return -EINVAL;
+
+	parse_params(&prs, n_params, params);
+
+	if (spa_pod_parser_get(&prs,
+				SPA_POD_PodStruct(&ipod), NULL) < 0)
+		return -EINVAL;
+
+	if (ipod) {
+		struct spa_pod_parser p2;
+		struct spa_pod_frame f2;
+		infop = &info;
+
+		spa_pod_parser_pod(&p2, ipod);
+		if (spa_pod_parser_push_struct(&p2, &f2) < 0 ||
+		    spa_pod_parser_get(&p2,
+				SPA_POD_Int(&info.max_input_ports),
+				SPA_POD_Int(&info.max_output_ports),
+				SPA_POD_Long(&info.change_mask),
+				SPA_POD_Long(&info.flags), NULL) < 0)
+			return -EINVAL;
+
+		info.change_mask &= SPA_NODE_CHANGE_MASK_FLAGS |
+				SPA_NODE_CHANGE_MASK_PROPS |
+				SPA_NODE_CHANGE_MASK_PARAMS;
+
+		parse_dict(&p2, &props);
+		if (props.n_items > 0)
+			info.props = &props;
+
+		parse_param_info(&p2, info.n_params, info.params);
+	}
+
+	pw_resource_notify(resource, struct pw_client_node_methods, update, 0, change_mask,
+									n_params,
+									params, infop);
+	return 0;
+}
+
+static int client_node_demarshal_port_update(void *object, const struct pw_protocol_native_message *msg)
+{
+	struct pw_resource *resource = object;
+	struct spa_pod_parser prs;
+	struct spa_pod_frame f;
+	uint32_t direction, port_id, change_mask, n_params;
+	const struct spa_pod **params = NULL;
+	struct spa_port_info info = SPA_PORT_INFO_INIT(), *infop = NULL;
+	struct spa_pod *ipod;
+	struct spa_dict props = SPA_DICT_INIT(NULL, 0);
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_push_struct(&prs, &f) < 0 ||
+	    spa_pod_parser_get(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id),
+			SPA_POD_Int(&change_mask), NULL) < 0)
+		return -EINVAL;
+
+	parse_params(&prs, n_params, params);
+
+	if (spa_pod_parser_get(&prs,
+				SPA_POD_PodStruct(&ipod), NULL) < 0)
+		return -EINVAL;
+
+	if (ipod) {
+		struct spa_pod_parser p2;
+		struct spa_pod_frame f2;
+		infop = &info;
+
+		spa_pod_parser_pod(&p2, ipod);
+		if (spa_pod_parser_push_struct(&p2, &f2) < 0 ||
+		    spa_pod_parser_get(&p2,
+				SPA_POD_Long(&info.change_mask),
+				SPA_POD_Long(&info.flags),
+				SPA_POD_Int(&info.rate.num),
+				SPA_POD_Int(&info.rate.denom), NULL) < 0)
+			return -EINVAL;
+
+		info.change_mask &= SPA_PORT_CHANGE_MASK_FLAGS |
+				SPA_PORT_CHANGE_MASK_RATE |
+				SPA_PORT_CHANGE_MASK_PROPS |
+				SPA_PORT_CHANGE_MASK_PARAMS;
+
+		parse_dict(&p2, &props);
+		if (props.n_items > 0)
+			info.props = &props;
+
+		parse_param_info(&p2, info.n_params, info.params);
+	}
+
+	pw_resource_notify(resource, struct pw_client_node_methods, port_update, 0, direction,
+									     port_id,
+									     change_mask,
+									     n_params,
+									     params, infop);
+	return 0;
+}
+
+static int client_node_demarshal_set_active(void *object, const struct pw_protocol_native_message *msg)
+{
+	struct pw_resource *resource = object;
+	struct spa_pod_parser prs;
+	bool active;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+				SPA_POD_Bool(&active)) < 0)
+		return -EINVAL;
+
+	pw_resource_notify(resource, struct pw_client_node_methods, set_active, 0, active);
+	return 0;
+}
+
+static int client_node_demarshal_event_method(void *object, const struct pw_protocol_native_message *msg)
+{
+	struct pw_resource *resource = object;
+	struct spa_pod_parser prs;
+	const struct spa_event *event;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_get_struct(&prs,
+			SPA_POD_PodObject(&event)) < 0)
+		return -EINVAL;
+
+	pw_resource_notify(resource, struct pw_client_node_methods, event, 0, event);
+	return 0;
+}
+
+static int client_node_demarshal_port_buffers(void *object, const struct pw_protocol_native_message *msg)
+{
+	struct pw_resource *resource = object;
+	struct spa_pod_parser prs;
+	struct spa_pod_frame f;
+	uint32_t i, j, direction, port_id, mix_id, n_buffers;
+	int64_t data_fd;
+	struct spa_buffer **buffers = NULL;
+
+	spa_pod_parser_init(&prs, msg->data, msg->size);
+	if (spa_pod_parser_push_struct(&prs, &f) < 0 ||
+	    spa_pod_parser_get(&prs,
+			SPA_POD_Int(&direction),
+			SPA_POD_Int(&port_id),
+			SPA_POD_Int(&mix_id),
+			SPA_POD_Int(&n_buffers), NULL) < 0)
+		return -EINVAL;
+
+	if (n_buffers > MAX_BUFFERS)
+		return -ENOSPC;
+
+	buffers = alloca(sizeof(struct spa_buffer*) * n_buffers);
+	for (i = 0; i < n_buffers; i++) {
+		struct spa_buffer *buf = buffers[i] = alloca(sizeof(struct spa_buffer));
+
+		spa_zero(*buf);
+		if (spa_pod_parser_get(&prs,
+					SPA_POD_Int(&buf->n_datas), NULL) < 0)
+			return -EINVAL;
+
+		if (buf->n_datas > MAX_DATAS)
+			return -ENOSPC;
+
+		buf->datas = alloca(sizeof(struct spa_data) * buf->n_datas);
+		for (j = 0; j < buf->n_datas; j++) {
+			struct spa_data *d = &buf->datas[j];
+
+			if (spa_pod_parser_get(&prs,
+					      SPA_POD_Id(&d->type),
+					      SPA_POD_Fd(&data_fd),
+					      SPA_POD_Int(&d->flags),
+					      SPA_POD_Int(&d->mapoffset),
+					      SPA_POD_Int(&d->maxsize), NULL) < 0)
+				return -EINVAL;
+
+			d->fd = pw_protocol_native_get_resource_fd(resource, data_fd);
+		}
+	}
+
+	pw_resource_notify(resource, struct pw_client_node_methods, port_buffers, 0,
+			direction, port_id, mix_id, n_buffers, buffers);
+
+	return 0;
+}
+
+static const struct pw_client_node_methods pw_protocol_native_client_node_method_marshal = {
+	PW_VERSION_CLIENT_NODE_METHODS,
+	.add_listener = &client_node_marshal_add_listener,
+	.get_node = &client_node_marshal_get_node,
+	.update = &client_node_marshal_update,
+	.port_update = &client_node_marshal_port_update,
+	.set_active = &client_node_marshal_set_active,
+	.event = &client_node_marshal_event_method,
+	.port_buffers = &client_node_marshal_port_buffers
+};
+
+static const struct pw_protocol_native_demarshal
+pw_protocol_native_client_node_method_demarshal[PW_CLIENT_NODE_METHOD_NUM] =
+{
+	[PW_CLIENT_NODE_METHOD_ADD_LISTENER] = { NULL, 0 },
+	[PW_CLIENT_NODE_METHOD_GET_NODE] = { &client_node_demarshal_get_node, 0 },
+	[PW_CLIENT_NODE_METHOD_UPDATE] = { &client_node_demarshal_update, 0 },
+	[PW_CLIENT_NODE_METHOD_PORT_UPDATE] = { &client_node_demarshal_port_update, 0 },
+	[PW_CLIENT_NODE_METHOD_SET_ACTIVE] = { &client_node_demarshal_set_active, 0 },
+	[PW_CLIENT_NODE_METHOD_EVENT] = { &client_node_demarshal_event_method, 0 },
+	[PW_CLIENT_NODE_METHOD_PORT_BUFFERS] = { &client_node_demarshal_port_buffers, 0 }
+};
+
+static const struct pw_client_node_events pw_protocol_native_client_node_event_marshal = {
+	PW_VERSION_CLIENT_NODE_EVENTS,
+	.transport = &client_node_marshal_transport,
+	.set_param = &client_node_marshal_set_param,
+	.set_io = &client_node_marshal_set_io,
+	.event = &client_node_marshal_event_event,
+	.command = &client_node_marshal_command,
+	.add_port = &client_node_marshal_add_port,
+	.remove_port = &client_node_marshal_remove_port,
+	.port_set_param = &client_node_marshal_port_set_param,
+	.port_use_buffers = &client_node_marshal_port_use_buffers,
+	.port_set_io = &client_node_marshal_port_set_io,
+	.set_activation = &client_node_marshal_set_activation,
+	.port_set_mix_info = &client_node_marshal_port_set_mix_info,
+};
+
+static const struct pw_protocol_native_demarshal
+pw_protocol_native_client_node_event_demarshal[PW_CLIENT_NODE_EVENT_NUM] =
+{
+	[PW_CLIENT_NODE_EVENT_TRANSPORT] = { &client_node_demarshal_transport, 0 },
+	[PW_CLIENT_NODE_EVENT_SET_PARAM] = { &client_node_demarshal_set_param, 0 },
+	[PW_CLIENT_NODE_EVENT_SET_IO] = { &client_node_demarshal_set_io, 0 },
+	[PW_CLIENT_NODE_EVENT_EVENT] = { &client_node_demarshal_event_event, 0 },
+	[PW_CLIENT_NODE_EVENT_COMMAND] = { &client_node_demarshal_command, 0 },
+	[PW_CLIENT_NODE_EVENT_ADD_PORT] = { &client_node_demarshal_add_port, 0 },
+	[PW_CLIENT_NODE_EVENT_REMOVE_PORT] = { &client_node_demarshal_remove_port, 0 },
+	[PW_CLIENT_NODE_EVENT_PORT_SET_PARAM] = { &client_node_demarshal_port_set_param, 0 },
+	[PW_CLIENT_NODE_EVENT_PORT_USE_BUFFERS] = { &client_node_demarshal_port_use_buffers, 0 },
+	[PW_CLIENT_NODE_EVENT_PORT_SET_IO] = { &client_node_demarshal_port_set_io, 0 },
+	[PW_CLIENT_NODE_EVENT_SET_ACTIVATION] = { &client_node_demarshal_set_activation, 0 },
+	[PW_CLIENT_NODE_EVENT_PORT_SET_MIX_INFO] = { &client_node_demarshal_port_set_mix_info, 0 }
+};
+
+static const struct pw_protocol_marshal pw_protocol_native_client_node_marshal = {
+	PW_TYPE_INTERFACE_ClientNode,
+	PW_VERSION_CLIENT_NODE,
+	0,
+	PW_CLIENT_NODE_METHOD_NUM,
+	PW_CLIENT_NODE_EVENT_NUM,
+	.client_marshal = &pw_protocol_native_client_node_method_marshal,
+	.server_demarshal = &pw_protocol_native_client_node_method_demarshal,
+	.server_marshal = &pw_protocol_native_client_node_event_marshal,
+	.client_demarshal = pw_protocol_native_client_node_event_demarshal,
+};
+
+struct pw_protocol *pw_protocol_native_ext_client_node_init(struct pw_context *context)
+{
+	struct pw_protocol *protocol;
+
+	protocol = pw_context_find_protocol(context, PW_TYPE_INFO_PROTOCOL_Native);
+
+	if (protocol == NULL)
+		return NULL;
+
+	pw_protocol_add_marshal(protocol, &pw_protocol_native_client_node_marshal);
+
+	return protocol;
+}