audioconvert: improvements

spa/plugins/audioconvert/fmt-ops.c

@@ -22,6 +22,16 @@
 
 #include <spa/utils/defs.h>
 
+#define U8_TO_F32(v)	(((v) / 128.0) - 1.0)
+
+#define F32_TO_U8(v)		\
+({				\
+	typeof(v) _v = (v);	\
+	_v < -1.0f ? 0 :	\
+	_v >= 1.0f ? 255 :	\
+	(_v * 127.0f) + 128.0f;	\
+})
+
 #define S16_TO_F32(v)	((v) / 32767.0)
 
 #define F32_TO_S16(v)		\
@@ -33,7 +43,7 @@
 })
 
 static void
-s16_to_f32(void *dst, const void *src, int n_bytes)
+conv_s16_to_f32(void *dst, const void *src, int n_bytes)
 {
 	const int16_t *s = src;
 	float *d = dst;
@@ -44,51 +54,98 @@ s16_to_f32(void *dst, const void *src, int n_bytes)
 }
 
 static void
-s16_to_f32_di(int n_dst, void *dst[n_dst], const void *src, int n_bytes)
+conv_s16_to_f32d(int n_dst, void *dst[n_dst], const void *src, int n_bytes)
 {
 	const int16_t *s = src;
 	float **d = (float **) dst;
 	int i;
 
-	n_bytes /= sizeof(int16_t);
+	n_bytes /= (sizeof(int16_t) * n_dst);
 	while (n_bytes--)
 		for (i = 0; i < n_dst; i++)
 			*d[i]++ = S16_TO_F32(*s++);
 }
 
 static void
-s16_to_f32_i(void *dst, int n_src, const void *src[n_src], int n_bytes)
+conv_f32d_to_s16(void *dst, int n_src, const void *src[n_src], int n_bytes)
 {
-	const int16_t **s = src;
+	const int16_t **s = (const int16_t **) src;
 	float *d = dst;
 	int i;
 
-	n_bytes /= sizeof(int16_t);
+	n_bytes /= (sizeof(float) * n_src);
 	while (n_bytes--)
 		for (i = 0; i < n_src; i++)
-			*d++ = S16_TO_F32(*s[i]++);
+			*d++ = F32_TO_S16(*s[i]++);
 }
 
 static void
-f32_to_s16(void *dst, const void *src, int n_bytes)
+conv_f32_to_s16(void *dst, const void *src, int n_bytes)
 {
 	const float *s = src;
 	int16_t *d = dst;
 
 	n_bytes /= sizeof(float);
-	while (n_bytes--) {
-		*d++ = F32_TO_S16(*s);
-		s++;
-	}
+	while (n_bytes--)
+		*d++ = F32_TO_S16(*s++);
+}
+
+
+static void
+conv_u8_to_f32(void *dst, const void *src, int n_bytes)
+{
+	const int8_t *s = src;
+	float *d = dst;
+
+	while (n_bytes--)
+		*d++ = U8_TO_F32(*s++);
 }
 
 static void
-deinterleave_1(void *dst[], int n_dst, const void *src, int n_bytes)
+conv_u8_to_f32d(int n_dst, void *dst[n_dst], const void *src, int n_bytes)
+{
+	const int8_t *s = src;
+	float **d = (float **) dst;
+	int i;
+
+	n_bytes /= n_dst;
+	while (n_bytes--)
+		for (i = 0; i < n_dst; i++)
+			*d[i]++ = U8_TO_F32(*s++);
+}
+
+static void
+conv_f32d_to_u8(void *dst, int n_src, const void *src[n_src], int n_bytes)
+{
+	const int8_t **s = (const int8_t **) src;
+	float *d = dst;
+	int i;
+
+	n_bytes /= (sizeof(float) * n_src);
+	while (n_bytes--)
+		for (i = 0; i < n_src; i++)
+			*d++ = F32_TO_U8(*s[i]++);
+}
+
+static void
+conv_f32_to_u8(void *dst, const void *src, int n_bytes)
+{
+	const float *s = src;
+	int8_t *d = dst;
+
+	n_bytes /= sizeof(float);
+	while (n_bytes--)
+		*d++ = F32_TO_U8(*s++);
+}
+
+static void
+deinterleave_8(int n_dst, void *dst[n_dst], const void *src, int n_bytes)
 {
 	const uint8_t *s = src;
 	uint8_t **d = (uint8_t **) dst;
 	int i;
 
+	n_bytes /= n_dst;
 	while (n_bytes--) {
 		for (i = 0; i < n_dst; i++)
 			*d[i]++ = *s++;
@@ -96,13 +153,13 @@ deinterleave_1(void *dst[], int n_dst, const void *src, int n_bytes)
 }
 
 static void
-deinterleave_2(void *dst[], int n_dst, const void *src, int n_bytes)
+deinterleave_16(int n_dst, void *dst[n_dst], const void *src, int n_bytes)
 {
 	const uint16_t *s = src;
 	uint16_t **d = (uint16_t **) dst;
 	int i;
 
-	n_bytes /= sizeof(uint16_t);
+	n_bytes /= (sizeof(uint16_t) * n_dst);
 	while (n_bytes--) {
 		for (i = 0; i < n_dst; i++)
 			*d[i]++ = *s++;
@@ -110,15 +167,29 @@ deinterleave_2(void *dst[], int n_dst, const void *src, int n_bytes)
 }
 
 static void
-deinterleave_4(void *dst[], int n_dst, const void *src, int n_bytes)
+deinterleave_32(int n_dst, void *dst[n_dst], const void *src, int n_bytes)
 {
 	const uint32_t *s = src;
 	uint32_t **d = (uint32_t **) dst;
 	int i;
 
-	n_bytes /= sizeof(uint32_t);
+	n_bytes /= (sizeof(uint32_t) * n_dst);
 	while (n_bytes--) {
 		for (i = 0; i < n_dst; i++)
 			*d[i]++ = *s++;
 	}
 }
+
+static void
+interleave_32(void *dst, int n_src, const void *src[n_src], int n_bytes)
+{
+	const int32_t **s = (const int32_t **) src;
+	uint32_t *d = dst;
+	int i;
+
+	n_bytes /= (sizeof(uint32_t) * n_src);
+	while (n_bytes--) {
+		for (i = 0; i < n_src; i++)
+			*d++ = *s[i]++;
+	}
+}

spa/plugins/audioconvert/fmtconvert.c

@@ -40,6 +40,8 @@
 #define PROP_DEFAULT_TRUNCATE	false
 #define PROP_DEFAULT_DITHER	0
 
+struct impl;
+
 struct props {
 	bool truncate;
 	uint32_t dither;
@@ -57,6 +59,7 @@ struct buffer {
 	uint32_t flags;
 	struct spa_buffer *outbuf;
 	struct spa_meta_header *h;
+	size_t n_bytes;
 };
 
 struct port {
@@ -114,6 +117,36 @@ static inline void init_type(struct type *type, struct spa_type_map *map)
 	spa_type_param_io_map(map, &type->param_io);
 }
 
+
+#include "fmt-ops.c"
+
+static const struct pack_info {
+	off_t format;
+	void (*unpack_func) (int n_dst, void *dst[n_dst], const void *src, int n_bytes);
+	void (*unpack_func_1) (void *dst, const void *src, int n_bytes);
+	void (*pack_func) (void *dst, int n_src, const void *src[n_src], int n_bytes);
+	void (*pack_func_1) (void *dst, const void *src, int n_bytes);
+} pack_table[] =
+{
+	{ offsetof(struct spa_type_audio_format, U8),
+		conv_u8_to_f32d, conv_u8_to_f32, conv_f32d_to_u8, conv_f32_to_u8 },
+	{ offsetof(struct spa_type_audio_format, S16),
+		conv_s16_to_f32d, conv_s16_to_f32, conv_f32d_to_s16, conv_f32_to_s16 },
+	{ offsetof(struct spa_type_audio_format, F32),
+		deinterleave_32, NULL, interleave_32, NULL },
+};
+
+struct chain {
+	struct chain *prev;
+
+	uint32_t flags;
+	const struct pack_info *pack;
+
+	struct buffer *dst;
+
+	int (*process) (struct impl *impl, struct chain *chain);
+};
+
 struct impl {
 	struct spa_handle handle;
 	struct spa_node node;
@@ -132,7 +165,13 @@ struct impl {
 
 	bool started;
 
+	struct chain chains[10];
+	struct chain *start;
+
+	const struct buffer *src;
+
 	int (*convert) (struct impl *impl, const struct buffer *src, struct buffer *dst);
+
 };
 
 #define CHECK_PORT(this,d,id)		(id == 0)
@@ -140,6 +179,182 @@ struct impl {
 #define GET_OUT_PORT(this,id)		(&this->out_port)
 #define GET_PORT(this,d,id)		(d == SPA_DIRECTION_INPUT ? GET_IN_PORT(this,id) : GET_OUT_PORT(this,id))
 
+static const struct pack_info *find_pack_info(struct impl *this, uint32_t format)
+{
+	struct type *t = &this->type;
+	int i;
+
+	for (i = 0; i < SPA_N_ELEMENTS(pack_table); i++) {
+		if (*SPA_MEMBER(&t->audio_format, pack_table[i].format, uint32_t) == format)
+			return &pack_table[i];
+	}
+	return NULL;
+}
+
+static int convert_generic(struct impl *this, const struct buffer *src, struct buffer *dst)
+{
+	struct chain *start = this->start;
+
+	this->src = src;
+	start->dst = dst;
+
+	spa_log_trace(this->log, NAME " %p", this);
+
+	return start->process(this, start);
+}
+
+static int do_unpack(struct impl *this, struct chain *chain)
+{
+	struct spa_buffer *src, *dst;
+	uint32_t i, size;
+
+	src = this->src->outbuf;
+	dst = chain->dst->outbuf;
+
+	spa_log_trace(this->log, NAME " %p: %d->%d", this, src->n_datas, dst->n_datas);
+
+	if (src->n_datas == dst->n_datas) {
+		for (i = 0; i < dst->n_datas; i++) {
+			size = src->datas[i].chunk->size;
+			chain->pack->unpack_func_1(dst->datas[i].data,
+						   src->datas[i].data, size);
+			dst->datas[i].chunk->size = size;
+		}
+	}
+	else {
+		void *datas[dst->n_datas];
+
+		for (i = 0; i < dst->n_datas; i++)
+			datas[i] = dst->datas[i].data;
+
+		chain->pack->unpack_func(dst->n_datas,
+				         datas,
+				         src->datas[0].data,
+					 src->datas[0].chunk->size);
+	}
+	return 0;
+}
+
+static int do_pack(struct impl *this, struct chain *chain)
+{
+	struct chain *prev = chain->prev;
+	struct spa_buffer *src, *dst;
+	uint32_t i, size;
+
+	if (prev) {
+		prev->dst = chain->dst;
+		prev->process(this, prev);
+		src = prev->dst->outbuf;
+	} else {
+		src = this->src->outbuf;
+	}
+	dst = chain->dst->outbuf;
+
+	spa_log_trace(this->log, NAME " %p: %d->%d", this, src->n_datas, dst->n_datas);
+
+	if (src->n_datas == dst->n_datas) {
+		for (i = 0; i < dst->n_datas; i++) {
+			size = src->datas[i].chunk->size;
+			chain->pack->pack_func_1(dst->datas[i].data,
+						 src->datas[i].data, size);
+			dst->datas[i].chunk->size = size;
+		}
+	}
+	else {
+		const void *datas[src->n_datas];
+
+		for (i = 0; i < src->n_datas; i++)
+			datas[i] = src->datas[i].data;
+
+		chain->pack->pack_func(dst->datas[0].data,
+				       src->n_datas,
+				       datas,
+				       src->datas[0].chunk->size);
+	}
+	return 0;
+}
+
+static struct chain *alloc_chain(struct impl *this, struct chain *prev)
+{
+	struct chain *chain;
+	if (prev == NULL)
+		chain = this->chains;
+	else
+		chain = prev + 1;
+	chain->prev = prev;
+	return chain;
+}
+
+static int setup_convert(struct impl *this)
+{
+	struct port *inport, *outport;
+	const struct pack_info *pack_info;
+	struct chain *chain = NULL;
+	struct type *t = &this->type;
+	uint32_t channels, rate;
+
+	inport = GET_PORT(this, SPA_DIRECTION_INPUT, 0);
+	outport = GET_PORT(this, SPA_DIRECTION_OUTPUT, 0);
+
+	spa_log_info(this->log, NAME " %p: %d/%d@%d->%d/%d@%d", this,
+			inport->format.info.raw.format,
+			inport->format.info.raw.channels,
+			inport->format.info.raw.rate,
+			outport->format.info.raw.format,
+			outport->format.info.raw.channels,
+			outport->format.info.raw.rate);
+
+	channels = inport->format.info.raw.channels;
+	rate = inport->format.info.raw.rate;
+
+	/* unpack */
+	if (inport->format.info.raw.format != t->audio_format.F32 ||
+	    (inport->format.info.raw.channels > 1 &&
+	     inport->format.info.raw.layout != SPA_AUDIO_LAYOUT_NON_INTERLEAVED)) {
+		if ((pack_info = find_pack_info(this, inport->format.info.raw.format)) == NULL)
+			return -EINVAL;
+
+		spa_log_info(this->log, NAME " %p: setup unpack", this);
+		chain = alloc_chain(this, chain);
+		chain->pack = pack_info;
+		chain->process = do_unpack;
+	}
+
+	/* down mix */
+	if (channels > outport->format.info.raw.channels) {
+		spa_log_info(this->log, NAME " %p: setup downmix", this);
+		channels = outport->format.info.raw.channels;
+	}
+	/* resample */
+	if (rate != outport->format.info.raw.rate) {
+		spa_log_info(this->log, NAME " %p: setup resample", this);
+		rate = outport->format.info.raw.rate;
+	}
+
+	/* up mix */
+	if (channels < outport->format.info.raw.channels) {
+		spa_log_info(this->log, NAME " %p: setup upmix", this);
+		channels = outport->format.info.raw.channels;
+	}
+
+	/* pack */
+	if (outport->format.info.raw.format != t->audio_format.F32 ||
+	    (outport->format.info.raw.channels > 1 &&
+	     outport->format.info.raw.layout != SPA_AUDIO_LAYOUT_NON_INTERLEAVED)) {
+		if ((pack_info = find_pack_info(this, outport->format.info.raw.format)) == NULL)
+			return -EINVAL;
+		spa_log_info(this->log, NAME " %p: setup pack", this);
+		chain = alloc_chain(this, chain);
+		chain->pack = pack_info;
+		chain->process = do_pack;
+	}
+
+	this->start = chain;
+	this->convert = convert_generic;
+
+	return 0;
+}
+
 static int impl_node_enum_params(struct spa_node *node,
 				 uint32_t id, uint32_t *index,
 				 const struct spa_pod *filter,
@@ -320,7 +535,6 @@ static int port_enum_formats(struct spa_node *node,
 				":", t->format_audio.layout,   "ieu", SPA_AUDIO_LAYOUT_INTERLEAVED,
 					SPA_POD_PROP_ENUM(2, SPA_AUDIO_LAYOUT_INTERLEAVED,
 							     SPA_AUDIO_LAYOUT_NON_INTERLEAVED),
-				":", t->format_audio.rate,     "i", other->format.info.raw.rate,
 				":", t->format_audio.rate,     "iru", 44100,
 					SPA_POD_PROP_MIN_MAX(1, INT32_MAX),
 				":", t->format_audio.channels, "iru", 2,
@@ -481,16 +695,19 @@ static int port_set_format(struct spa_node *node,
 			   const struct spa_pod *format)
 {
 	struct impl *this = SPA_CONTAINER_OF(node, struct impl, node);
-	struct port *port;
+	struct port *port, *other;
 	struct type *t = &this->type;
+	int res = 0;
 
 	port = GET_PORT(this, direction, port_id);
+	other = GET_PORT(this, SPA_DIRECTION_REVERSE(direction), port_id);
 
 	if (format == NULL) {
 		if (port->have_format) {
 			port->have_format = false;
 			clear_buffers(this, port);
 		}
+		this->convert = NULL;
 	} else {
 		struct spa_audio_info info = { 0 };
 
@@ -508,13 +725,14 @@ static int port_set_format(struct spa_node *node,
 		port->have_format = true;
 		port->format = info;
 
-		spa_log_info(this->log, NAME " %p: set format on port %d", this, port_id);
+		if (other->have_format)
+			res = setup_convert(this);
+
+		spa_log_info(this->log, NAME " %p: set format on port %d %d", this, port_id, res);
 	}
-
-	return 0;
+	return res;
 }
 
-
 static int
 impl_node_port_set_param(struct spa_node *node,
 			 enum spa_direction direction, uint32_t port_id,

spa/plugins/audioconvert/meson.build

@@ -1,4 +1,4 @@
-audioconvert_sources = ['fmtconvert.c', 'fmt-ops.c', 'plugin.c']
+audioconvert_sources = ['fmtconvert.c', 'plugin.c']
 
 audioconvertlib = shared_library('spa-audioconvert',
                           audioconvert_sources,

spa/tests/meson.build

@@ -3,6 +3,11 @@ executable('test-mixer', 'test-mixer.c',
            dependencies : [dl_lib, pthread_lib, mathlib],
            link_with : spalib,
            install : false)
+executable('test-convert', 'test-convert.c',
+           include_directories : [spa_inc, spa_libinc ],
+           dependencies : [dl_lib, pthread_lib, mathlib],
+           link_with : spalib,
+           install : false)
 executable('test-bluez5', 'test-bluez5.c',
            include_directories : [spa_inc, spa_libinc ],
            dependencies : [dl_lib, pthread_lib, mathlib, dbus_dep],

spa/tests/test-convert.c

@@ -0,0 +1,389 @@
+/* Spa
+ * Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <pthread.h>
+#include <poll.h>
+
+#include <spa/support/log-impl.h>
+#include <spa/support/loop.h>
+#include <spa/support/type-map-impl.h>
+#include <spa/node/node.h>
+#include <spa/node/io.h>
+#include <spa/param/param.h>
+#include <spa/param/props.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/format-utils.h>
+
+#include <lib/debug.h>
+
+static SPA_TYPE_MAP_IMPL(default_map, 4096);
+static SPA_LOG_IMPL(default_log);
+
+struct type {
+	uint32_t node;
+	uint32_t props;
+	uint32_t format;
+	uint32_t props_device;
+	uint32_t props_freq;
+	uint32_t props_volume;
+	uint32_t props_min_latency;
+	uint32_t props_live;
+	struct spa_type_io io;
+	struct spa_type_param param;
+	struct spa_type_meta meta;
+	struct spa_type_data data;
+	struct spa_type_media_type media_type;
+	struct spa_type_media_subtype media_subtype;
+	struct spa_type_format_audio format_audio;
+	struct spa_type_audio_format audio_format;
+	struct spa_type_event_node event_node;
+	struct spa_type_command_node command_node;
+};
+
+static inline void init_type(struct type *type, struct spa_type_map *map)
+{
+	type->node = spa_type_map_get_id(map, SPA_TYPE__Node);
+	type->props = spa_type_map_get_id(map, SPA_TYPE__Props);
+	type->format = spa_type_map_get_id(map, SPA_TYPE__Format);
+	type->props_device = spa_type_map_get_id(map, SPA_TYPE_PROPS__device);
+	type->props_freq = spa_type_map_get_id(map, SPA_TYPE_PROPS__frequency);
+	type->props_volume = spa_type_map_get_id(map, SPA_TYPE_PROPS__volume);
+	type->props_min_latency = spa_type_map_get_id(map, SPA_TYPE_PROPS__minLatency);
+	type->props_live = spa_type_map_get_id(map, SPA_TYPE_PROPS__live);
+	spa_type_io_map(map, &type->io);
+	spa_type_param_map(map, &type->param);
+	spa_type_meta_map(map, &type->meta);
+	spa_type_data_map(map, &type->data);
+	spa_type_media_type_map(map, &type->media_type);
+	spa_type_media_subtype_map(map, &type->media_subtype);
+	spa_type_format_audio_map(map, &type->format_audio);
+	spa_type_audio_format_map(map, &type->audio_format);
+	spa_type_event_node_map(map, &type->event_node);
+	spa_type_command_node_map(map, &type->command_node);
+}
+
+struct buffer {
+	struct spa_buffer buffer;
+	struct spa_meta metas[1];
+	struct spa_meta_header header;
+	struct spa_data datas[8];
+	struct spa_chunk chunks[8];
+};
+
+struct data {
+	struct spa_type_map *map;
+	struct spa_log *log;
+	struct type type;
+
+	struct spa_support support[4];
+	uint32_t n_support;
+
+	struct spa_node *conv;
+	struct spa_io_buffers io_in[1];
+	struct spa_io_buffers io_out[1];
+
+	struct spa_buffer *in_buffers[1];
+	struct buffer in_buffer[1];
+	struct spa_buffer *out_buffers[1];
+	struct buffer out_buffer[1];
+};
+
+#define BUFFER_SIZE     4096
+
+static void
+init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int n_buffers,
+	    size_t size, int n_datas)
+{
+	int i, j;
+	void *d;
+
+	for (i = 0; i < n_buffers; i++) {
+		struct buffer *b = &ba[i];
+		bufs[i] = &b->buffer;
+
+		b->buffer.id = i;
+		b->buffer.metas = b->metas;
+		b->buffer.n_metas = 1;
+		b->buffer.datas = b->datas;
+		b->buffer.n_datas = n_datas;
+
+		b->header.flags = 0;
+		b->header.seq = 0;
+		b->header.pts = 0;
+		b->header.dts_offset = 0;
+		b->metas[0].type = data->type.meta.Header;
+		b->metas[0].data = &b->header;
+		b->metas[0].size = sizeof(b->header);
+
+		d = malloc(size * n_datas);
+
+		for (j = 0; j < n_datas; j++) {
+			b->datas[j].type = data->type.data.MemPtr;
+			b->datas[j].flags = 0;
+			b->datas[j].fd = -1;
+			b->datas[j].mapoffset = 0;
+			b->datas[j].maxsize = size;
+			b->datas[j].data = SPA_MEMBER(d, size * j, void);
+			b->datas[j].chunk = &b->chunks[0];
+			b->datas[j].chunk->offset = 0;
+			b->datas[j].chunk->size = 0;
+			b->datas[j].chunk->stride = 0;
+		}
+	}
+}
+
+static int make_node(struct data *data, struct spa_node **node, const char *lib, const char *name)
+{
+	struct spa_handle *handle;
+	int res;
+	void *hnd;
+	spa_handle_factory_enum_func_t enum_func;
+	uint32_t i;
+
+	if ((hnd = dlopen(lib, RTLD_NOW)) == NULL) {
+		printf("can't load %s: %s\n", lib, dlerror());
+		return -errno;
+	}
+	if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
+		printf("can't find enum function\n");
+		return -errno;
+	}
+
+	for (i = 0;;) {
+		const struct spa_handle_factory *factory;
+		void *iface;
+
+		if ((res = enum_func(&factory, &i)) <= 0) {
+			if (res != 0)
+				printf("can't enumerate factories: %s\n", spa_strerror(res));
+			break;
+		}
+		if (strcmp(factory->name, name))
+			continue;
+
+		handle = calloc(1, factory->size);
+		if ((res =
+		     spa_handle_factory_init(factory, handle, NULL, data->support,
+					     data->n_support)) < 0) {
+			printf("can't make factory instance: %d\n", res);
+			return res;
+		}
+		if ((res = spa_handle_get_interface(handle, data->type.node, &iface)) < 0) {
+			printf("can't get interface %d\n", res);
+			return res;
+		}
+		*node = iface;
+		return 0;
+	}
+	return -EBADF;
+}
+
+static void on_conv_done(void *data, int seq, int res)
+{
+	printf("got done %d %d\n", seq, res);
+}
+
+static void on_conv_event(void *data, struct spa_event *event)
+{
+	printf("got event %d\n", SPA_EVENT_TYPE(event));
+}
+
+static void on_conv_process(void *_data, int status)
+{
+	printf("got process\n");
+}
+
+static void
+on_conv_reuse_buffer(void *_data,
+		     uint32_t port_id,
+		     uint32_t buffer_id)
+{
+	printf("got reuse buffer\n");
+}
+
+static const struct spa_node_callbacks conv_callbacks = {
+	SPA_VERSION_NODE_CALLBACKS,
+	.done = on_conv_done,
+	.event = on_conv_event,
+	.process = on_conv_process,
+	.reuse_buffer = on_conv_reuse_buffer
+};
+
+static int make_nodes(struct data *data, const char *device)
+{
+	int res;
+
+	if ((res = make_node(data, &data->conv,
+			     "build/spa/plugins/audioconvert/libspa-audioconvert.so", "fmtconvert")) < 0) {
+		printf("can't create fmtconvert: %d\n", res);
+		return res;
+	}
+	spa_node_set_callbacks(data->conv, &conv_callbacks, data);
+
+	return res;
+}
+
+static int negotiate_formats(struct data *data)
+{
+	int res;
+	struct spa_pod *format;
+	struct spa_pod_builder b = { 0 };
+	uint8_t buffer[4096];
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	format = spa_pod_builder_object(&b,
+		0, data->type.format,
+		"I", data->type.media_type.audio,
+		"I", data->type.media_subtype.raw,
+		":", data->type.format_audio.format,   "I", data->type.audio_format.S16,
+		":", data->type.format_audio.layout,   "i", SPA_AUDIO_LAYOUT_INTERLEAVED,
+		":", data->type.format_audio.rate,     "i", 44100,
+		":", data->type.format_audio.channels, "i", 2);
+
+	if ((res = spa_node_port_set_param(data->conv,
+					   SPA_DIRECTION_INPUT, 0,
+					   data->type.param.idFormat, 0,
+					   format)) < 0)
+		return res;
+
+	data->io_in[0] = SPA_IO_BUFFERS_INIT;
+	data->io_out[0] = SPA_IO_BUFFERS_INIT;
+
+	spa_node_port_set_io(data->conv,
+			     SPA_DIRECTION_INPUT, 0,
+			     data->type.io.Buffers,
+			     &data->io_in[0], sizeof(data->io_in[0]));
+	spa_node_port_set_io(data->conv,
+			     SPA_DIRECTION_OUTPUT, 0,
+			     data->type.io.Buffers,
+			     &data->io_out[0], sizeof(data->io_out[0]));
+
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	format = spa_pod_builder_object(&b,
+		0, data->type.format,
+		"I", data->type.media_type.audio,
+		"I", data->type.media_subtype.raw,
+		":", data->type.format_audio.format,   "I", data->type.audio_format.F32,
+		":", data->type.format_audio.layout,   "i", SPA_AUDIO_LAYOUT_NON_INTERLEAVED,
+		":", data->type.format_audio.rate,     "i", 44100,
+		":", data->type.format_audio.channels, "i", 2);
+
+
+	if ((res = spa_node_port_set_param(data->conv,
+					   SPA_DIRECTION_OUTPUT, 0,
+					   data->type.param.idFormat, 0,
+					   format)) < 0)
+		return res;
+
+	init_buffer(data, data->in_buffers, data->in_buffer, 1, BUFFER_SIZE, 1);
+	if ((res =
+	     spa_node_port_use_buffers(data->conv, SPA_DIRECTION_INPUT, 0, data->in_buffers,
+				       1)) < 0)
+		return res;
+
+	init_buffer(data, data->out_buffers, data->out_buffer, 1, BUFFER_SIZE / 2, 2);
+	if ((res =
+	     spa_node_port_use_buffers(data->conv, SPA_DIRECTION_OUTPUT, 0, data->out_buffers,
+				       1)) < 0)
+		return res;
+
+	return 0;
+}
+
+static void fill_buffer(struct data *data, struct spa_buffer *buffers[], int id)
+{
+	int i;
+
+	for (i = 0; i < BUFFER_SIZE; i++) {
+		*SPA_MEMBER(buffers[id]->datas[0].data, i, uint8_t) = i;
+	}
+	buffers[id]->datas[0].chunk->size = BUFFER_SIZE;
+}
+
+static void run_convert(struct data *data)
+{
+	int res;
+
+	{
+		struct spa_command cmd = SPA_COMMAND_INIT(data->type.command_node.Start);
+		if ((res = spa_node_send_command(data->conv, &cmd)) < 0)
+			printf("got convert error %d\n", res);
+	}
+
+	fill_buffer(data, data->in_buffers, 0);
+
+	data->io_in[0].status = SPA_STATUS_HAVE_BUFFER;
+	data->io_in[0].buffer_id = 0;
+
+	data->io_out[0].status = SPA_STATUS_NEED_BUFFER;
+	data->io_out[0].buffer_id = 0;
+
+	spa_debug_dump_mem(data->in_buffers[0]->datas[0].data, BUFFER_SIZE);
+
+	res = spa_node_process(data->conv);
+	printf("called process %d\n", res);
+
+	spa_debug_dump_mem(data->out_buffers[0]->datas[0].data, BUFFER_SIZE / 2);
+	spa_debug_dump_mem(data->out_buffers[0]->datas[1].data, BUFFER_SIZE / 2);
+
+	{
+		struct spa_command cmd = SPA_COMMAND_INIT(data->type.command_node.Pause);
+		if ((res = spa_node_send_command(data->conv, &cmd)) < 0)
+			printf("got convert error %d\n", res);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { NULL };
+	int res;
+	const char *str;
+
+	data.map = &default_map.map;
+	data.log = &default_log.log;
+
+	if ((str = getenv("SPA_DEBUG")))
+		data.log->level = atoi(str);
+
+	data.support[0].type = SPA_TYPE__TypeMap;
+	data.support[0].data = data.map;
+	data.support[1].type = SPA_TYPE__Log;
+	data.support[1].data = data.log;
+	data.n_support = 2;
+
+	init_type(&data.type, data.map);
+
+	if ((res = make_nodes(&data, argc > 1 ? argv[1] : NULL)) < 0) {
+		printf("can't make nodes: %d\n", res);
+		return -1;
+	}
+	if ((res = negotiate_formats(&data)) < 0) {
+		printf("can't negotiate nodes: %d\n", res);
+		return -1;
+	}
+
+	run_convert(&data);
+}