/* PipeWire
 *
 * Copyright © 2020 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 "config.h"

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>

#include <pipewire/log.h>

#include "log.h"

#include <spa/support/cpu.h>
#include <spa/utils/result.h>
#include <spa/utils/string.h>
#include <spa/debug/dict.h>
#include <spa/debug/mem.h>
#include <spa/debug/types.h>
#include <spa/param/audio/raw.h>
#include <spa/pod/pod.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/props.h>
#include <spa/utils/ringbuffer.h>
#include <spa/utils/json.h>

#include <pipewire/pipewire.h>
#include <pipewire/extensions/metadata.h>

#include "pulse-server.h"
#include "client.h"
#include "collect.h"
#include "commands.h"
#include "cmd.h"
#include "dbus-name.h"
#include "defs.h"
#include "extension.h"
#include "format.h"
#include "internal.h"
#include "manager.h"
#include "message.h"
#include "message-handler.h"
#include "module.h"
#include "operation.h"
#include "pending-sample.h"
#include "quirks.h"
#include "reply.h"
#include "sample.h"
#include "sample-play.h"
#include "server.h"
#include "stream.h"
#include "utils.h"
#include "volume.h"

#define DEFAULT_MIN_REQ		"256/48000"
#define DEFAULT_DEFAULT_REQ	"960/48000"
#define DEFAULT_MIN_FRAG	"256/48000"
#define DEFAULT_DEFAULT_FRAG	"96000/48000"
#define DEFAULT_DEFAULT_TLENGTH	"96000/48000"
#define DEFAULT_MIN_QUANTUM	"256/48000"
#define DEFAULT_FORMAT		"F32"
#define DEFAULT_POSITION	"[ FL FR ]"
#define DEFAULT_IDLE_TIMEOUT	"0"

#define MAX_FORMATS	32
/* The max amount of data we send in one block when capturing. In PulseAudio this
 * size is derived from the mempool PA_MEMPOOL_SLOT_SIZE */
#define MAX_BLOCK	(64*1024)

#define TEMPORARY_MOVE_TIMEOUT	(SPA_NSEC_PER_SEC)

PW_LOG_TOPIC_EXTERN(pulse_conn);

bool debug_messages = false;

struct latency_offset_data {
	int64_t prev_latency_offset;
	uint8_t initialized:1;
};

struct temporary_move_data {
	uint32_t peer_index;
	uint8_t used:1;
};

static struct sample *find_sample(struct impl *impl, uint32_t index, const char *name)
{
	union pw_map_item *item;

	if (index != SPA_ID_INVALID)
		return pw_map_lookup(&impl->samples, index);

	pw_array_for_each(item, &impl->samples.items) {
		struct sample *s = item->data;
		if (!pw_map_item_is_free(item) &&
		    spa_streq(s->name, name))
			return s;
	}
	return NULL;
}

void broadcast_subscribe_event(struct impl *impl, uint32_t mask, uint32_t event, uint32_t index)
{
	struct server *s;
	spa_list_for_each(s, &impl->servers, link) {
		struct client *c;
		spa_list_for_each(c, &s->clients, link)
			client_queue_subscribe_event(c, mask, event, index);
	}
}

static int do_command_auth(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct message *reply;
	uint32_t version;
	const void *cookie;
	size_t len;

	if (message_get(m,
			TAG_U32, &version,
			TAG_ARBITRARY, &cookie, &len,
			TAG_INVALID) < 0) {
		return -EPROTO;
	}
	if (version < 8)
		return -EPROTO;
	if (len != NATIVE_COOKIE_LENGTH)
		return -EINVAL;

	if ((version & PROTOCOL_VERSION_MASK) >= 13)
		version &= PROTOCOL_VERSION_MASK;

	client->version = version;
	client->authenticated = true;

	pw_log_info("client:%p AUTH tag:%u version:%d", client, tag, version);

	reply = reply_new(client, tag);
	message_put(reply,
			TAG_U32, PROTOCOL_VERSION,
			TAG_INVALID);

	return client_queue_message(client, reply);
}

static int reply_set_client_name(struct client *client, uint32_t tag)
{
	struct pw_manager *manager = client->manager;
	struct message *reply;
	struct pw_client *c;
	uint32_t id, index;

	c = pw_core_get_client(client->core);
	if (c == NULL)
		return -ENOENT;

	id = pw_proxy_get_bound_id((struct pw_proxy*)c);
	index = id_to_index(manager, id);

	pw_log_info("[%s] reply tag:%u id:%u index:%u", client->name, tag, id, index);

	reply = reply_new(client, tag);

	if (client->version >= 13) {
		message_put(reply,
			TAG_U32, index,		/* client index */
			TAG_INVALID);
	}
	return client_queue_message(client, reply);
}

static void manager_sync(void *data)
{
	struct client *client = data;
	struct operation *o;

	pw_log_debug("%p: manager sync", client);

	if (client->connect_tag != SPA_ID_INVALID) {
		reply_set_client_name(client, client->connect_tag);
		client->connect_tag = SPA_ID_INVALID;
	}

	client->ref++;
	spa_list_consume(o, &client->operations, link)
		operation_complete(o);
	client_unref(client);
}

static struct stream *find_stream(struct client *client, uint32_t index)
{
	union pw_map_item *item;
	pw_array_for_each(item, &client->streams.items) {
		struct stream *s = item->data;
		if (!pw_map_item_is_free(item) &&
		    s->index == index)
			return s;
	}
	return NULL;
}

static int send_object_event(struct client *client, struct pw_manager_object *o,
		uint32_t type)
{
	uint32_t event = 0, mask = 0, res_index = o->index;

	if (pw_manager_object_is_sink(o)) {
		client_queue_subscribe_event(client,
				SUBSCRIPTION_MASK_SINK,
				SUBSCRIPTION_EVENT_SINK | type,
				res_index);
	}
	if (pw_manager_object_is_source_or_monitor(o)) {
		mask = SUBSCRIPTION_MASK_SOURCE;
		event = SUBSCRIPTION_EVENT_SOURCE;
	}
	else if (pw_manager_object_is_sink_input(o)) {
		mask = SUBSCRIPTION_MASK_SINK_INPUT;
		event = SUBSCRIPTION_EVENT_SINK_INPUT;
	}
	else if (pw_manager_object_is_source_output(o)) {
		mask = SUBSCRIPTION_MASK_SOURCE_OUTPUT;
		event = SUBSCRIPTION_EVENT_SOURCE_OUTPUT;
	}
	else if (pw_manager_object_is_module(o)) {
		mask = SUBSCRIPTION_MASK_MODULE;
		event = SUBSCRIPTION_EVENT_MODULE;
	}
	else if (pw_manager_object_is_client(o)) {
		mask = SUBSCRIPTION_MASK_CLIENT;
		event = SUBSCRIPTION_EVENT_CLIENT;
	}
	else if (pw_manager_object_is_card(o)) {
		mask = SUBSCRIPTION_MASK_CARD;
		event = SUBSCRIPTION_EVENT_CARD;
	} else
		event = SPA_ID_INVALID;

	if (event != SPA_ID_INVALID)
		client_queue_subscribe_event(client,
				mask,
				event | type,
				res_index);
	return 0;
}

static uint32_t get_temporary_move_target(struct client *client, struct pw_manager_object *o)
{
	struct temporary_move_data *d;

	d = pw_manager_object_get_data(o, "temporary_move_data");
	if (d == NULL || d->peer_index == SPA_ID_INVALID)
		return SPA_ID_INVALID;

	pw_log_debug("[%s] using temporary move target for index:%d -> index:%d",
			client->name, o->index, d->peer_index);
	d->used = true;
	return d->peer_index;
}

static void set_temporary_move_target(struct client *client, struct pw_manager_object *o, uint32_t index)
{
	struct temporary_move_data *d;

	if (!pw_manager_object_is_sink_input(o) && !pw_manager_object_is_source_output(o))
		return;

	if (index == SPA_ID_INVALID) {
		d = pw_manager_object_get_data(o, "temporary_move_data");
		if (d == NULL)
			return;
		if (d->peer_index != SPA_ID_INVALID)
			pw_log_debug("cleared temporary move target for index:%d", o->index);
		d->peer_index = SPA_ID_INVALID;
		d->used = false;
		return;
	}

	d = pw_manager_object_add_temporary_data(o, "temporary_move_data",
			sizeof(struct temporary_move_data),
			TEMPORARY_MOVE_TIMEOUT);
	if (d == NULL)
		return;

	pw_log_debug("[%s] set temporary move target for index:%d to index:%d",
			client->name, o->index, index);
	d->peer_index = index;
	d->used = false;
}

static void temporary_move_target_timeout(struct client *client, struct pw_manager_object *o)
{
	struct temporary_move_data *d = pw_manager_object_get_data(o, "temporary_move_data");
	struct pw_manager_object *peer;

	/*
	 * Send change event if the temporary data was used, and the peer
	 * is not what we claimed.
	 */

	if (d == NULL || d->peer_index == SPA_ID_INVALID || !d->used)
		goto done;

	peer = find_linked(client->manager, o->id, pw_manager_object_is_sink_input(o) ?
			PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT);
	if (peer == NULL || peer->index != d->peer_index) {
		pw_log_debug("[%s] temporary move timeout for index:%d, send change event",
				client->name, o->index);
		send_object_event(client, o, SUBSCRIPTION_EVENT_CHANGE);
	}

done:
	set_temporary_move_target(client, o, SPA_ID_INVALID);
}

static struct pw_manager_object *find_device(struct client *client,
		uint32_t index, const char *name, bool sink, bool *is_monitor);

static int64_t get_node_latency_offset(struct pw_manager_object *o)
{
	int64_t latency_offset = 0LL;
	struct pw_manager_param *p;

	spa_list_for_each(p, &o->param_list, link) {
		if (p->id != SPA_PARAM_Props)
			continue;
		if (spa_pod_parse_object(p->param,
					SPA_TYPE_OBJECT_Props, NULL,
					SPA_PROP_latencyOffsetNsec, SPA_POD_Long(&latency_offset)) == 1)
			break;
	}
	return latency_offset;
}

static void send_latency_offset_subscribe_event(struct client *client, struct pw_manager_object *o)
{
	struct pw_manager *manager = client->manager;
	struct latency_offset_data *d;
	struct pw_node_info *info;
	const char *str;
	uint32_t card_id = SPA_ID_INVALID;
	int64_t latency_offset = 0LL;
	bool changed = false;

	if (!pw_manager_object_is_sink(o) && !pw_manager_object_is_source_or_monitor(o))
		return;

	/*
	 * Pulseaudio sends card change events on latency offset change.
	 */
	if ((info = o->info) == NULL || info->props == NULL)
		return;
	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_ID)) != NULL)
		card_id = (uint32_t)atoi(str);
	if (card_id == SPA_ID_INVALID)
		return;

	d = pw_manager_object_add_data(o, "latency_offset_data", sizeof(struct latency_offset_data));
	if (d == NULL)
		return;

	latency_offset = get_node_latency_offset(o);
	changed = (!d->initialized || latency_offset != d->prev_latency_offset);

	d->prev_latency_offset = latency_offset;
	d->initialized = true;

	if (changed)
		client_queue_subscribe_event(client,
				SUBSCRIPTION_MASK_CARD,
				SUBSCRIPTION_EVENT_CARD | SUBSCRIPTION_EVENT_CHANGE,
				id_to_index(manager, card_id));
}

static void send_default_change_subscribe_event(struct client *client, bool sink, bool source)
{
	struct pw_manager_object *def;
	bool changed = false;

	if (sink) {
		def = find_device(client, SPA_ID_INVALID, NULL, true, NULL);
		if (client->prev_default_sink != def) {
			client->prev_default_sink = def;
			changed = true;
		}
	}

	if (source) {
		def = find_device(client, SPA_ID_INVALID, NULL, false, NULL);
		if (client->prev_default_source != def) {
			client->prev_default_source = def;
			changed = true;
		}
	}

	if (changed)
		client_queue_subscribe_event(client,
				SUBSCRIPTION_MASK_SERVER,
				SUBSCRIPTION_EVENT_CHANGE |
				SUBSCRIPTION_EVENT_SERVER,
				-1);
}

static void handle_metadata(struct client *client, struct pw_manager_object *old,
		struct pw_manager_object *new, const char *name)
{
	if (spa_streq(name, "default")) {
		if (client->metadata_default == old)
			client->metadata_default = new;
	}
	else if (spa_streq(name, "route-settings")) {
		if (client->metadata_routes == old)
			client->metadata_routes = new;
	}
}

static uint32_t frac_to_bytes_round_up(struct spa_fraction val, const struct sample_spec *ss)
{
	uint64_t u;
	u = (uint64_t) (val.num * 1000000UL * (uint64_t) ss->rate) / val.denom;
	u = (u + 1000000UL - 1) / 1000000UL;
	u *= sample_spec_frame_size(ss);
	return (uint32_t) u;
}

static void clamp_latency(struct stream *s, struct spa_fraction *lat)
{
	if (lat->num * s->min_quantum.denom / lat->denom < s->min_quantum.num)
		lat->num = (s->min_quantum.num * lat->denom +
				(s->min_quantum.denom -1)) / s->min_quantum.denom;
}

static uint64_t fix_playback_buffer_attr(struct stream *s, struct buffer_attr *attr,
		uint32_t rate, struct spa_fraction *lat)
{
	uint32_t frame_size, max_prebuf, minreq, latency, max_latency, maxlength;
	struct defs *defs = &s->impl->defs;

	if ((frame_size = s->frame_size) == 0)
		frame_size = sample_spec_frame_size(&s->ss);
	if (frame_size == 0)
		frame_size = 4;

	maxlength = SPA_ROUND_DOWN(MAXLENGTH, frame_size);

	pw_log_info("[%s] maxlength:%u tlength:%u minreq:%u prebuf:%u max:%u",
			s->client->name, attr->maxlength, attr->tlength,
			attr->minreq, attr->prebuf, maxlength);

	minreq = frac_to_bytes_round_up(s->min_req, &s->ss);
	max_latency = defs->quantum_limit * frame_size;

	if (attr->maxlength == (uint32_t) -1 || attr->maxlength > maxlength)
		attr->maxlength = maxlength;
	else
		attr->maxlength = SPA_ROUND_DOWN(attr->maxlength, frame_size);

	minreq = SPA_MIN(minreq, attr->maxlength);

	if (attr->tlength == (uint32_t) -1)
		attr->tlength = frac_to_bytes_round_up(s->default_tlength, &s->ss);
	attr->tlength = SPA_CLAMP(attr->tlength, minreq, attr->maxlength);
	attr->tlength = SPA_ROUND_UP(attr->tlength, frame_size);

	if (attr->minreq == (uint32_t) -1) {
		uint32_t process = frac_to_bytes_round_up(s->default_req, &s->ss);
		/* With low-latency, tlength/4 gives a decent default in all of traditional,
		 * adjust latency and early request modes. */
		uint32_t m = attr->tlength / 4;
		m = SPA_ROUND_DOWN(m, frame_size);
		attr->minreq = SPA_MIN(process, m);
	}
	attr->minreq = SPA_MAX(attr->minreq, minreq);

	if (attr->tlength < attr->minreq+frame_size)
		attr->tlength = SPA_MIN(attr->minreq + frame_size, attr->maxlength);

	if (s->early_requests) {
		latency = attr->minreq;
	} else if (s->adjust_latency) {
		if (attr->tlength > attr->minreq * 2)
			latency = SPA_MIN(max_latency, (attr->tlength - attr->minreq * 2) / 2);
		else
			latency = attr->minreq;

		latency = SPA_ROUND_DOWN(latency, frame_size);

		if (attr->tlength >= latency)
			attr->tlength -= latency;
	} else {
		if (attr->tlength > attr->minreq * 2)
			latency = SPA_MIN(max_latency, attr->tlength - attr->minreq * 2);
		else
			latency = attr->minreq;
	}

	if (attr->tlength < latency + 2 * attr->minreq)
		attr->tlength = SPA_MIN(latency + 2 * attr->minreq, attr->maxlength);

	attr->minreq = SPA_ROUND_DOWN(attr->minreq, frame_size);
	if (attr->minreq <= 0) {
		attr->minreq = frame_size;
		attr->tlength += frame_size*2;
	}
	if (attr->tlength <= attr->minreq)
		attr->tlength = SPA_MIN(attr->minreq*2 + frame_size, attr->maxlength);

	max_prebuf = attr->tlength + frame_size - attr->minreq;
	if (attr->prebuf == (uint32_t) -1 || attr->prebuf > max_prebuf)
		attr->prebuf = max_prebuf;
	attr->prebuf = SPA_ROUND_DOWN(attr->prebuf, frame_size);

	attr->fragsize = 0;

	lat->num = latency / frame_size;
	lat->denom = rate;
	clamp_latency(s, lat);

	pw_log_info("[%s] maxlength:%u tlength:%u minreq:%u/%u prebuf:%u latency:%u/%u %u",
			s->client->name, attr->maxlength, attr->tlength,
			attr->minreq, minreq, attr->prebuf, lat->num, lat->denom, frame_size);

	return lat->num * SPA_USEC_PER_SEC / lat->denom;
}

static uint64_t set_playback_buffer_attr(struct stream *s, struct buffer_attr *attr)
{
	struct spa_fraction lat;
	uint64_t lat_usec;
	struct spa_dict_item items[6];
	char latency[32], rate[32];
	char attr_maxlength[32];
	char attr_tlength[32];
	char attr_prebuf[32];
	char attr_minreq[32];

	lat_usec = fix_playback_buffer_attr(s, attr, s->ss.rate, &lat);

	s->attr = *attr;

	snprintf(latency, sizeof(latency), "%u/%u", lat.num, lat.denom);
	snprintf(rate, sizeof(rate), "1/%u", lat.denom);
	snprintf(attr_maxlength, sizeof(attr_maxlength), "%u", s->attr.maxlength);
	snprintf(attr_tlength, sizeof(attr_tlength), "%u", s->attr.tlength);
	snprintf(attr_prebuf, sizeof(attr_prebuf), "%u", s->attr.prebuf);
	snprintf(attr_minreq, sizeof(attr_minreq), "%u", s->attr.minreq);

	items[0] = SPA_DICT_ITEM_INIT(PW_KEY_NODE_LATENCY, latency);
	items[1] = SPA_DICT_ITEM_INIT(PW_KEY_NODE_RATE, rate);
	items[2] = SPA_DICT_ITEM_INIT("pulse.attr.maxlength", attr_maxlength);
	items[3] = SPA_DICT_ITEM_INIT("pulse.attr.tlength", attr_tlength);
	items[4] = SPA_DICT_ITEM_INIT("pulse.attr.prebuf", attr_prebuf);
	items[5] = SPA_DICT_ITEM_INIT("pulse.attr.minreq", attr_minreq);
	pw_stream_update_properties(s->stream, &SPA_DICT_INIT(items, 6));

	if (s->attr.prebuf > 0)
		s->in_prebuf = true;

	return lat_usec;
}

static int reply_create_playback_stream(struct stream *stream, struct pw_manager_object *peer)
{
	struct client *client = stream->client;
	struct pw_manager *manager = client->manager;
	struct message *reply;
	uint32_t missing, peer_index;
	const char *peer_name;
	uint64_t lat_usec;

	stream->buffer = calloc(1, MAXLENGTH);
	if (stream->buffer == NULL)
		return -errno;

	lat_usec = set_playback_buffer_attr(stream, &stream->attr);

	missing = stream_pop_missing(stream);
	stream->index = id_to_index(manager, stream->id);
	stream->lat_usec = lat_usec;

	pw_log_info("[%s] reply CREATE_PLAYBACK_STREAM tag:%u index:%u missing:%u lat:%"PRIu64,
			client->name, stream->create_tag, stream->index, missing, lat_usec);

	reply = reply_new(client, stream->create_tag);
	message_put(reply,
		TAG_U32, stream->channel,		/* stream index/channel */
		TAG_U32, stream->index,			/* sink_input/stream index */
		TAG_U32, missing,			/* missing/requested bytes */
		TAG_INVALID);

	if (peer && pw_manager_object_is_sink(peer)) {
		peer_index = peer->index;
		peer_name = pw_properties_get(peer->props, PW_KEY_NODE_NAME);
	} else {
		peer_index = SPA_ID_INVALID;
		peer_name = NULL;
	}

	if (client->version >= 9) {
		message_put(reply,
			TAG_U32, stream->attr.maxlength,
			TAG_U32, stream->attr.tlength,
			TAG_U32, stream->attr.prebuf,
			TAG_U32, stream->attr.minreq,
			TAG_INVALID);
	}
	if (client->version >= 12) {
		message_put(reply,
			TAG_SAMPLE_SPEC, &stream->ss,
			TAG_CHANNEL_MAP, &stream->map,
			TAG_U32, peer_index,		/* sink index */
			TAG_STRING, peer_name,		/* sink name */
			TAG_BOOLEAN, false,		/* sink suspended state */
			TAG_INVALID);
	}
	if (client->version >= 13) {
		message_put(reply,
			TAG_USEC, lat_usec,		/* sink configured latency */
			TAG_INVALID);
	}
	if (client->version >= 21) {
		struct format_info info;
		spa_zero(info);
		info.encoding = ENCODING_PCM;
		message_put(reply,
			TAG_FORMAT_INFO, &info,		/* sink_input format */
			TAG_INVALID);
	}

	stream->create_tag = SPA_ID_INVALID;

	return client_queue_message(client, reply);
}

static uint64_t fix_record_buffer_attr(struct stream *s, struct buffer_attr *attr,
		uint32_t rate, struct spa_fraction *lat)
{
	uint32_t frame_size, minfrag, latency, maxlength;

	if ((frame_size = s->frame_size) == 0)
		frame_size = sample_spec_frame_size(&s->ss);
	if (frame_size == 0)
		frame_size = 4;

	maxlength = SPA_ROUND_DOWN(MAXLENGTH, frame_size);

	pw_log_info("[%s] maxlength:%u fragsize:%u framesize:%u",
			s->client->name, attr->maxlength, attr->fragsize,
			frame_size);

	if (attr->maxlength == (uint32_t) -1 || attr->maxlength > maxlength)
		attr->maxlength = maxlength;
	else
		attr->maxlength = SPA_ROUND_DOWN(attr->maxlength, frame_size);
	attr->maxlength = SPA_MAX(attr->maxlength, frame_size);

	minfrag = frac_to_bytes_round_up(s->min_frag, &s->ss);

	if (attr->fragsize == (uint32_t) -1 || attr->fragsize == 0)
		attr->fragsize = frac_to_bytes_round_up(s->default_frag, &s->ss);
	attr->fragsize = SPA_CLAMP(attr->fragsize, minfrag, attr->maxlength);
	attr->fragsize = SPA_ROUND_UP(attr->fragsize, frame_size);

	attr->tlength = attr->minreq = attr->prebuf = 0;

	/* make sure we can queue at least to fragsize without overruns */
	if (attr->maxlength < attr->fragsize * 4) {
		attr->maxlength = attr->fragsize * 4;
		if (attr->maxlength > maxlength) {
			attr->maxlength = maxlength;
			attr->fragsize = SPA_ROUND_DOWN(maxlength / 4, frame_size);
		}
	}

	latency = attr->fragsize;

	lat->num = latency / frame_size;
	lat->denom = rate;
	clamp_latency(s, lat);

	pw_log_info("[%s] maxlength:%u fragsize:%u minfrag:%u latency:%u/%u",
			s->client->name, attr->maxlength, attr->fragsize, minfrag,
			lat->num, lat->denom);

	return lat->num * SPA_USEC_PER_SEC / lat->denom;
}

static uint64_t set_record_buffer_attr(struct stream *s, struct buffer_attr *attr)
{
	struct spa_dict_item items[4];
	char latency[32], rate[32];
	char attr_maxlength[32];
	char attr_fragsize[32];
	struct spa_fraction lat;
	uint64_t lat_usec;

	lat_usec = fix_record_buffer_attr(s, attr, s->ss.rate, &lat);

	s->attr = *attr;

	snprintf(latency, sizeof(latency), "%u/%u", lat.num, lat.denom);
	snprintf(rate, sizeof(rate), "1/%u", lat.denom);

	snprintf(attr_maxlength, sizeof(attr_maxlength), "%u", s->attr.maxlength);
	snprintf(attr_fragsize, sizeof(attr_fragsize), "%u", s->attr.fragsize);

	items[0] = SPA_DICT_ITEM_INIT(PW_KEY_NODE_LATENCY, latency);
	items[1] = SPA_DICT_ITEM_INIT(PW_KEY_NODE_RATE, rate);
	items[2] = SPA_DICT_ITEM_INIT("pulse.attr.maxlength", attr_maxlength);
	items[3] = SPA_DICT_ITEM_INIT("pulse.attr.fragsize", attr_fragsize);
	pw_stream_update_properties(s->stream, &SPA_DICT_INIT(items, 4));

	return lat_usec;
}

static int reply_create_record_stream(struct stream *stream, struct pw_manager_object *peer)
{
	struct client *client = stream->client;
	struct pw_manager *manager = client->manager;
	char *tmp;
	struct message *reply;
	const char *peer_name, *name;
	uint32_t peer_index;
	uint64_t lat_usec;

	stream->buffer = calloc(1, MAXLENGTH);
	if (stream->buffer == NULL)
		return -errno;

	lat_usec = set_record_buffer_attr(stream, &stream->attr);

	stream->index = id_to_index(manager, stream->id);
	stream->lat_usec = lat_usec;

	pw_log_info("[%s] reply CREATE_RECORD_STREAM tag:%u index:%u latency:%"PRIu64,
			client->name, stream->create_tag, stream->index, lat_usec);

	reply = reply_new(client, stream->create_tag);
	message_put(reply,
		TAG_U32, stream->channel,	/* stream index/channel */
		TAG_U32, stream->index,		/* source_output/stream index */
		TAG_INVALID);

	if (peer && pw_manager_object_is_sink_input(peer))
		peer = find_linked(manager, peer->id, PW_DIRECTION_OUTPUT);
	if (peer && pw_manager_object_is_source_or_monitor(peer)) {
		name = pw_properties_get(peer->props, PW_KEY_NODE_NAME);
		peer_index = peer->index;
		if (!pw_manager_object_is_source(peer)) {
			size_t len = (name ? strlen(name) : 5) + 10;
			peer_name = tmp = alloca(len);
			snprintf(tmp, len, "%s.monitor", name ? name : "sink");
		} else {
			peer_name = name;
		}
	} else {
		peer_index = SPA_ID_INVALID;
		peer_name = NULL;
	}

	if (client->version >= 9) {
		message_put(reply,
			TAG_U32, stream->attr.maxlength,
			TAG_U32, stream->attr.fragsize,
			TAG_INVALID);
	}
	if (client->version >= 12) {
		message_put(reply,
			TAG_SAMPLE_SPEC, &stream->ss,
			TAG_CHANNEL_MAP, &stream->map,
			TAG_U32, peer_index,		/* source index */
			TAG_STRING, peer_name,		/* source name */
			TAG_BOOLEAN, false,		/* source suspended state */
			TAG_INVALID);
	}
	if (client->version >= 13) {
		message_put(reply,
			TAG_USEC, lat_usec,		/* source configured latency */
			TAG_INVALID);
	}
	if (client->version >= 22) {
		struct format_info info;
		spa_zero(info);
		info.encoding = ENCODING_PCM;
		message_put(reply,
			TAG_FORMAT_INFO, &info,		/* source_output format */
			TAG_INVALID);
	}

	stream->create_tag = SPA_ID_INVALID;

	return client_queue_message(client, reply);
}

static int reply_create_stream(struct stream *stream, struct pw_manager_object *peer)
{
	stream->peer_index = peer->index;
	return stream->direction == PW_DIRECTION_OUTPUT ?
			reply_create_playback_stream(stream, peer) :
			reply_create_record_stream(stream, peer);
}

static void manager_added(void *data, struct pw_manager_object *o)
{
	struct client *client = data;
	struct pw_manager *manager = client->manager;
	const char *str;

	register_object_message_handlers(o);

	if (strcmp(o->type, PW_TYPE_INTERFACE_Core) == 0 && manager->info != NULL) {
		struct pw_core_info *info = manager->info;
		if (info->props) {
			if ((str = spa_dict_lookup(info->props, "default.clock.rate")) != NULL)
				client->impl->defs.sample_spec.rate = atoi(str);
			if ((str = spa_dict_lookup(info->props, "default.clock.quantum-limit")) != NULL)
				client->impl->defs.quantum_limit = atoi(str);
		}
	}

	if (spa_streq(o->type, PW_TYPE_INTERFACE_Metadata)) {
		if (o->props != NULL &&
		    (str = pw_properties_get(o->props, PW_KEY_METADATA_NAME)) != NULL)
			handle_metadata(client, NULL, o, str);
	}

	if (spa_streq(o->type, PW_TYPE_INTERFACE_Link)) {
		struct stream *s, *t;
		struct pw_manager_object *peer = NULL;
		union pw_map_item *item;
		pw_array_for_each(item, &client->streams.items) {
			struct stream *s = item->data;
			const char *peer_name;

			if (pw_map_item_is_free(item) || s->pending)
				continue;
			if (s->peer_index == SPA_ID_INVALID)
				continue;

			peer = find_peer_for_link(manager, o, s->id, s->direction);
			if (peer == NULL || peer->props == NULL ||
			    peer->index == s->peer_index)
				continue;

			s->peer_index = peer->index;

			peer_name = pw_properties_get(peer->props, PW_KEY_NODE_NAME);
			if (peer_name && s->direction == PW_DIRECTION_INPUT &&
			    pw_manager_object_is_monitor(peer)) {
				int len = strlen(peer_name) + 10;
				char *tmp = alloca(len);
				snprintf(tmp, len, "%s.monitor", peer_name);
				peer_name = tmp;
			}
			if (peer_name != NULL)
				stream_send_moved(s, peer->index, peer_name);
		}
		spa_list_for_each_safe(s, t, &client->pending_streams, link) {
			peer = find_peer_for_link(manager, o, s->id, s->direction);
			if (peer) {
				reply_create_stream(s, peer);
				spa_list_remove(&s->link);
				s->pending = false;
			}
		}
	}

	send_object_event(client, o, SUBSCRIPTION_EVENT_NEW);

	/* Adding sinks etc. may also change defaults */
	send_default_change_subscribe_event(client, pw_manager_object_is_sink(o), pw_manager_object_is_source_or_monitor(o));
}

static void manager_updated(void *data, struct pw_manager_object *o)
{
	struct client *client = data;

	send_object_event(client, o, SUBSCRIPTION_EVENT_CHANGE);

	set_temporary_move_target(client, o, SPA_ID_INVALID);

	send_latency_offset_subscribe_event(client, o);
	send_default_change_subscribe_event(client, pw_manager_object_is_sink(o), pw_manager_object_is_source_or_monitor(o));
}

static void manager_removed(void *data, struct pw_manager_object *o)
{
	struct client *client = data;
	const char *str;

	send_object_event(client, o, SUBSCRIPTION_EVENT_REMOVE);

	send_default_change_subscribe_event(client, pw_manager_object_is_sink(o), pw_manager_object_is_source_or_monitor(o));

	if (spa_streq(o->type, PW_TYPE_INTERFACE_Metadata)) {
		if (o->props != NULL &&
		    (str = pw_properties_get(o->props, PW_KEY_METADATA_NAME)) != NULL)
			handle_metadata(client, o, NULL, str);
	}
}

static void manager_object_data_timeout(void *data, struct pw_manager_object *o, const char *key)
{
	struct client *client = data;

	if (spa_streq(key, "temporary_move_data"))
		temporary_move_target_timeout(client, o);
}

static int json_object_find(const char *obj, const char *key, char *value, size_t len)
{
	struct spa_json it[2];
	const char *v;
	char k[128];

	spa_json_init(&it[0], obj, strlen(obj));
	if (spa_json_enter_object(&it[0], &it[1]) <= 0)
		return -EINVAL;

	while (spa_json_get_string(&it[1], k, sizeof(k)) > 0) {
		if (spa_streq(k, key)) {
			if (spa_json_get_string(&it[1], value, len) <= 0)
				continue;
			return 0;
		} else {
			if (spa_json_next(&it[1], &v) <= 0)
				break;
		}
	}
	return -ENOENT;
}

static void manager_metadata(void *data, struct pw_manager_object *o,
		uint32_t subject, const char *key, const char *type, const char *value)
{
	struct client *client = data;
	bool changed = false;

	pw_log_debug("meta id:%d subject:%d key:%s type:%s value:%s",
			o->id, subject, key, type, value);

	if (subject == PW_ID_CORE && o == client->metadata_default) {
		char name[1024];

		if (key == NULL || spa_streq(key, "default.audio.sink")) {
			if (value != NULL) {
				if (json_object_find(value,
						"name", name, sizeof(name)) < 0)
					value = NULL;
				else
					value = name;
			}
			if ((changed = !spa_streq(client->default_sink, value))) {
				free(client->default_sink);
				client->default_sink = value ? strdup(value) : NULL;
			}
			free(client->temporary_default_sink);
			client->temporary_default_sink = NULL;
		}
		if (key == NULL || spa_streq(key, "default.audio.source")) {
			if (value != NULL) {
				if (json_object_find(value,
						"name", name, sizeof(name)) < 0)
					value = NULL;
				else
					value = name;
			}
			if ((changed = !spa_streq(client->default_source, value))) {
				free(client->default_source);
				client->default_source = value ? strdup(value) : NULL;
			}
			free(client->temporary_default_source);
			client->temporary_default_source = NULL;
		}
		if (changed)
			send_default_change_subscribe_event(client, true, true);
	}
	if (subject == PW_ID_CORE && o == client->metadata_routes) {
		if (key == NULL)
			pw_properties_clear(client->routes);
		else
			pw_properties_set(client->routes, key, value);
	}
}


static void do_free_client(void *obj, void *data, int res, uint32_t id)
{
	struct client *client = obj;
	client_free(client);
}

static void manager_disconnect(void *data)
{
	struct client *client = data;
	pw_log_debug("manager_disconnect()");
	pw_work_queue_add(client->impl->work_queue, client, 0,
				do_free_client, NULL);
}

static const struct pw_manager_events manager_events = {
	PW_VERSION_MANAGER_EVENTS,
	.sync = manager_sync,
	.added = manager_added,
	.updated = manager_updated,
	.removed = manager_removed,
	.metadata = manager_metadata,
	.disconnect = manager_disconnect,
	.object_data_timeout = manager_object_data_timeout,
};

static int do_set_client_name(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	const char *name = NULL;
	int res = 0, changed = 0;

	if (client->version < 13) {
		if (message_get(m,
				TAG_STRING, &name,
				TAG_INVALID) < 0)
			return -EPROTO;
		if (name)
			changed += pw_properties_set(client->props,
					PW_KEY_APP_NAME, name);
	} else {
		if (message_get(m,
				TAG_PROPLIST, client->props,
				TAG_INVALID) < 0)
			return -EPROTO;
		changed++;
	}

	client_update_quirks(client);

	client->name = pw_properties_get(client->props, PW_KEY_APP_NAME);
	pw_log_info("[%s] %s tag:%d", client->name,
			commands[command].name, tag);

	if (client->core == NULL) {
		client->core = pw_context_connect(impl->context,
				pw_properties_copy(client->props), 0);
		if (client->core == NULL) {
			res = -errno;
			goto error;
		}
		client->manager = pw_manager_new(client->core);
		if (client->manager == NULL) {
			res = -errno;
			goto error;
		}
		client->connect_tag = tag;
		pw_manager_add_listener(client->manager, &client->manager_listener,
				&manager_events, client);
	} else {
		if (changed)
			pw_core_update_properties(client->core, &client->props->dict);

		if (client->connect_tag == SPA_ID_INVALID)
			res = reply_set_client_name(client, tag);
	}

	return res;
error:
	pw_log_error("%p: failed to connect client: %s", impl, spa_strerror(res));
	return res;

}

static int do_subscribe(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t mask;

	if (message_get(m,
			TAG_U32, &mask,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] SUBSCRIBE tag:%u mask:%08x",
			client->name, tag, mask);

	if (mask & ~SUBSCRIPTION_MASK_ALL)
		return -EINVAL;

	client->subscribed = mask;

	return reply_simple_ack(client, tag);
}

static void stream_control_info(void *data, uint32_t id,
		const struct pw_stream_control *control)
{
	struct stream *stream = data;

	switch (id) {
	case SPA_PROP_channelVolumes:
		stream->volume.channels = control->n_values;
		memcpy(stream->volume.values, control->values, control->n_values * sizeof(float));
		pw_log_info("stream %p: volume changed %f", stream, stream->volume.values[0]);
		break;
	case SPA_PROP_mute:
		stream->muted = control->values[0] >= 0.5;
		pw_log_info("stream %p: mute changed %d", stream, stream->muted);
		break;
	}
}

static void do_destroy_stream(void *obj, void *data, int res, uint32_t id)
{
	struct stream *stream = obj;

	stream_free(stream);
}

static void stream_state_changed(void *data, enum pw_stream_state old,
		enum pw_stream_state state, const char *error)
{
	struct stream *stream = data;
	struct client *client = stream->client;
	struct impl *impl = client->impl;
	bool destroy_stream = false;

	switch (state) {
	case PW_STREAM_STATE_ERROR:
		reply_error(client, -1, stream->create_tag, -EIO);
		destroy_stream = true;
		break;
	case PW_STREAM_STATE_UNCONNECTED:
		if (stream->create_tag != SPA_ID_INVALID)
			reply_error(client, -1, stream->create_tag, -ENOENT);
		else
			stream->killed = true;
		destroy_stream = true;
		break;
	case PW_STREAM_STATE_PAUSED:
		stream->id = pw_stream_get_node_id(stream->stream);
		break;
	case PW_STREAM_STATE_CONNECTING:
	case PW_STREAM_STATE_STREAMING:
		break;
	}

	if (destroy_stream) {
		pw_work_queue_add(impl->work_queue, stream, 0,
				do_destroy_stream, NULL);
	}
}

static const struct spa_pod *get_buffers_param(struct stream *s,
		struct buffer_attr *attr, struct spa_pod_builder *b)
{
	const struct spa_pod *param;
	uint32_t blocks, buffers, size, maxsize, stride;
	struct defs *defs = &s->impl->defs;

	blocks = 1;
	stride = s->frame_size;

	maxsize = defs->quantum_limit * 32 * s->frame_size;
	if (s->direction == PW_DIRECTION_OUTPUT) {
		size = attr->minreq;
	} else {
		size = attr->fragsize;
	}
	buffers = SPA_CLAMP(maxsize / size, MIN_BUFFERS, MAX_BUFFERS);

	pw_log_info("[%s] stride %d maxsize %d size %u buffers %d", s->client->name,
			stride, maxsize, size, buffers);

	param = spa_pod_builder_add_object(b,
			SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
			SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(buffers,
				MIN_BUFFERS, MAX_BUFFERS),
			SPA_PARAM_BUFFERS_blocks,  SPA_POD_Int(blocks),
			SPA_PARAM_BUFFERS_size,    SPA_POD_CHOICE_RANGE_Int(
								size, size, maxsize),
			SPA_PARAM_BUFFERS_stride,  SPA_POD_Int(stride));
	return param;
}

static void stream_param_changed(void *data, uint32_t id, const struct spa_pod *param)
{
	struct stream *stream = data;
	const struct spa_pod *params[4];
	uint32_t n_params = 0;
	uint8_t buffer[4096];
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
	int res;

	if (id != SPA_PARAM_Format || param == NULL)
		return;

	if ((res = format_parse_param(param, false, &stream->ss, &stream->map, NULL, NULL)) < 0) {
		pw_stream_set_error(stream->stream, res, "format not supported");
		return;
	}

	pw_log_info("[%s] got format:%s rate:%u channels:%u", stream->client->name,
			format_id2name(stream->ss.format),
			stream->ss.rate, stream->ss.channels);

	stream->frame_size = sample_spec_frame_size(&stream->ss);
	if (stream->frame_size == 0) {
		pw_stream_set_error(stream->stream, res, "format not supported");
		return;
	}
	stream->rate = stream->ss.rate;

	if (stream->create_tag != SPA_ID_INVALID) {
		struct pw_manager_object *peer;

		if (stream->volume_set) {
			pw_stream_set_control(stream->stream,
				SPA_PROP_channelVolumes, stream->volume.channels, stream->volume.values, 0);
		}
		if (stream->muted_set) {
			float val = stream->muted ? 1.0f : 0.0f;
			pw_stream_set_control(stream->stream,
				SPA_PROP_mute, 1, &val, 0);
		}
		if (stream->corked)
			stream_set_paused(stream, true, "cork after create");

		/* if peer exists, reply immediately, otherwise reply when the link is created */
		peer = find_linked(stream->client->manager, stream->id, stream->direction);
		if (peer) {
			reply_create_stream(stream, peer);
		} else {
			spa_list_append(&stream->client->pending_streams, &stream->link);
			stream->pending = true;
		}
	}

	params[n_params++] = get_buffers_param(stream, &stream->attr, &b);
	pw_stream_update_params(stream->stream, params, n_params);
}

static void stream_io_changed(void *data, uint32_t id, void *area, uint32_t size)
{
	struct stream *stream = data;
	switch (id) {
	case SPA_IO_Position:
		stream->position = area;
		break;
	}
}

struct process_data {
	struct pw_time pwt;
	uint32_t read_inc;
	uint32_t write_inc;
	uint32_t underrun_for;
	uint32_t playing_for;
	uint32_t minreq;
	uint32_t quantum;
	unsigned int underrun:1;
	unsigned int idle:1;
};

static int
do_process_done(struct spa_loop *loop,
		bool async, uint32_t seq, const void *data, size_t size, void *user_data)
{
	struct stream *stream = user_data;
	struct client *client = stream->client;
	struct impl *impl = client->impl;
	const struct process_data *pd = data;
	uint32_t index, towrite;
	int32_t avail;

	stream->timestamp = pd->pwt.now;
	stream->delay = pd->pwt.buffered * SPA_USEC_PER_SEC / stream->ss.rate;
	if (pd->pwt.rate.denom > 0)
		stream->delay += pd->pwt.delay * SPA_USEC_PER_SEC * pd->pwt.rate.num / pd->pwt.rate.denom;

	if (stream->direction == PW_DIRECTION_OUTPUT) {
		if (pd->quantum != stream->last_quantum)
			stream_update_minreq(stream, pd->minreq);
		stream->last_quantum = pd->quantum;

		stream->read_index += pd->read_inc;
		if (stream->corked) {
			if (stream->underrun_for != (uint64_t)-1)
				stream->underrun_for += pd->underrun_for;
			stream->playing_for = 0;
			return 0;
		}
		if (pd->underrun != stream->is_underrun) {
			stream->is_underrun = pd->underrun;
			stream->underrun_for = 0;
			stream->playing_for = 0;
			if (pd->underrun)
				stream_send_underflow(stream, stream->read_index);
			else
				stream_send_started(stream);
		}
		if (pd->idle) {
			if (!stream->is_idle) {
				stream->idle_time = stream->timestamp;
			} else if (!stream->is_paused &&
			    stream->idle_timeout_sec > 0 &&
			    stream->timestamp - stream->idle_time >
					(stream->idle_timeout_sec * SPA_NSEC_PER_SEC)) {
				stream_set_paused(stream, true, "long underrun");
			}
		}
		stream->is_idle = pd->idle;
		stream->playing_for += pd->playing_for;
		if (stream->underrun_for != (uint64_t)-1)
			stream->underrun_for += pd->underrun_for;

		stream_send_request(stream);
	} else {
		struct message *msg;
		stream->write_index += pd->write_inc;

		avail = spa_ringbuffer_get_read_index(&stream->ring, &index);

		if (!spa_list_is_empty(&client->out_messages)) {
			pw_log_debug("%p: [%s] pending read:%u avail:%d",
					stream, client->name, index, avail);
			return 0;
		}

		if (avail <= 0) {
			/* underrun, can't really happen but if it does we
			 * do nothing and wait for more data */
			pw_log_warn("%p: [%s] underrun read:%u avail:%d",
					stream, client->name, index, avail);
		} else {
			if ((uint32_t)avail > stream->attr.maxlength) {
				uint32_t skip = avail - stream->attr.fragsize;
				/* overrun, catch up to latest fragment and send it */
				pw_log_warn("%p: [%s] overrun recover read:%u avail:%d max:%u skip:%u",
					stream, client->name, index, avail, stream->attr.maxlength, skip);
				index += skip;
				stream->read_index += skip;
				avail = stream->attr.fragsize;
			}
			pw_log_trace("avail:%d index:%u", avail, index);

			while ((uint32_t)avail >= stream->attr.fragsize) {
				towrite = SPA_MIN(avail, MAX_BLOCK);
				towrite = SPA_MIN(towrite, stream->attr.fragsize);
				towrite = SPA_ROUND_DOWN(towrite, stream->frame_size);

				msg = message_alloc(impl, stream->channel, towrite);
				if (msg == NULL)
					return -errno;

				spa_ringbuffer_read_data(&stream->ring,
						stream->buffer, MAXLENGTH,
						index % MAXLENGTH,
						msg->data, towrite);

				client_queue_message(client, msg);

				index += towrite;
				avail -= towrite;
				stream->read_index += towrite;
			}
			spa_ringbuffer_read_update(&stream->ring, index);
		}
	}
	return 0;
}


static void stream_process(void *data)
{
	struct stream *stream = data;
	struct client *client = stream->client;
	struct impl *impl = stream->impl;
	void *p;
	struct pw_buffer *buffer;
	struct spa_buffer *buf;
	struct spa_data *d;
	uint32_t offs, size, minreq = 0, index;
	struct process_data pd;
	bool do_flush = false;

	if (stream->create_tag != SPA_ID_INVALID)
		return;

	pw_log_trace_fp("%p: process", stream);
	buffer = pw_stream_dequeue_buffer(stream->stream);
	if (buffer == NULL)
		return;

	buf = buffer->buffer;
	d = &buf->datas[0];
	if ((p = d->data) == NULL)
		return;

	spa_zero(pd);

	if (stream->direction == PW_DIRECTION_OUTPUT) {
		int32_t avail = spa_ringbuffer_get_read_index(&stream->ring, &index);

		minreq = buffer->requested * stream->frame_size;
		if (minreq == 0)
			minreq = stream->attr.minreq;

		pd.minreq = minreq;
		pd.quantum = stream->position ? stream->position->clock.duration : minreq;

		if (avail < (int32_t)minreq || stream->corked) {
			/* underrun, produce a silence buffer */
			size = SPA_MIN(d->maxsize, minreq);
			memset(p, 0, size);

			if (stream->draining && !stream->corked) {
				stream->draining = false;
				do_flush = true;
			} else {
				pd.underrun_for = size;
				pd.underrun = true;
			}
			if ((stream->attr.prebuf == 0 || do_flush) && !stream->corked) {
				if (avail > 0) {
					avail = SPA_MIN((uint32_t)avail, size);
					spa_ringbuffer_read_data(&stream->ring,
						stream->buffer, MAXLENGTH,
						index % MAXLENGTH,
						p, avail);
				}
				index += size;
				pd.read_inc = size;
				spa_ringbuffer_read_update(&stream->ring, index);

				pd.playing_for = size;
			}
			pd.idle = true;
			pw_log_debug("%p: [%s] underrun read:%u avail:%d max:%u",
					stream, client->name, index, avail, minreq);
		} else {
			if (avail > (int32_t)stream->attr.maxlength) {
				uint32_t skip = avail - stream->attr.maxlength;
				/* overrun, reported by other side, here we skip
				 * ahead to the oldest data. */
				pw_log_debug("%p: [%s] overrun read:%u avail:%d max:%u skip:%u",
						stream, client->name, index, avail,
						stream->attr.maxlength, skip);
				index += skip;
				pd.read_inc = skip;
				avail = stream->attr.maxlength;
			}
			size = SPA_MIN(d->maxsize, (uint32_t)avail);
			size = SPA_MIN(size, minreq);

			spa_ringbuffer_read_data(&stream->ring,
					stream->buffer, MAXLENGTH,
					index % MAXLENGTH,
					p, size);

			index += size;
			pd.read_inc += size;
			spa_ringbuffer_read_update(&stream->ring, index);

			pd.playing_for = size;
			pd.underrun = false;
		}
		d->chunk->offset = 0;
		d->chunk->stride = stream->frame_size;
		d->chunk->size = size;
		buffer->size = size / stream->frame_size;
	} else  {
		int32_t filled = spa_ringbuffer_get_write_index(&stream->ring, &index);

		offs = SPA_MIN(d->chunk->offset, d->maxsize);
		size = SPA_MIN(d->chunk->size, d->maxsize - offs);

		if (filled < 0) {
			/* underrun, can't really happen because we never read more
			 * than what's available on the other side  */
			pw_log_warn("%p: [%s] underrun write:%u filled:%d",
					stream, client->name, index, filled);
		} else if ((uint32_t)filled + size > stream->attr.maxlength) {
			/* overrun, can happen when the other side is not
			 * reading fast enough. We still write our data into the
			 * ringbuffer and expect the other side to warn and catch up. */
			pw_log_debug("%p: [%s] overrun write:%u filled:%d size:%u max:%u",
					stream, client->name, index, filled,
					size, stream->attr.maxlength);
		}

		spa_ringbuffer_write_data(&stream->ring,
				stream->buffer, MAXLENGTH,
				index % MAXLENGTH,
				SPA_PTROFF(p, offs, void),
				SPA_MIN(size, MAXLENGTH));

		index += size;
		pd.write_inc = size;
		spa_ringbuffer_write_update(&stream->ring, index);
	}
	pw_stream_queue_buffer(stream->stream, buffer);

	if (do_flush)
		pw_stream_flush(stream->stream, true);

	pw_stream_get_time_n(stream->stream, &pd.pwt, sizeof(pd.pwt));

	pw_loop_invoke(impl->loop,
			do_process_done, 1, &pd, sizeof(pd), false, stream);
}

static void stream_drained(void *data)
{
	struct stream *stream = data;
	if (stream->drain_tag != 0) {
		pw_log_info("[%s] drained channel:%u tag:%d",
				stream->client->name, stream->channel,
				stream->drain_tag);
		reply_simple_ack(stream->client, stream->drain_tag);
		stream->drain_tag = 0;

		pw_stream_set_active(stream->stream, !stream->is_paused);
	}
}

static const struct pw_stream_events stream_events =
{
	PW_VERSION_STREAM_EVENTS,
	.control_info = stream_control_info,
	.state_changed = stream_state_changed,
	.param_changed = stream_param_changed,
	.io_changed = stream_io_changed,
	.process = stream_process,
	.drained = stream_drained,
};

static void log_format_info(struct impl *impl, enum spa_log_level level, struct format_info *format)
{
	const struct spa_dict_item *it;
	pw_logt(level, mod_topic, "%p: format %s",
			impl, format_encoding2name(format->encoding));
	spa_dict_for_each(it, &format->props->dict)
		pw_logt(level, mod_topic, "%p:  '%s': '%s'",
				impl, it->key, it->value);
}

static int do_create_playback_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	const char *name = NULL;
	int res;
	struct sample_spec ss;
	struct channel_map map;
	uint32_t sink_index, syncid, rate = 0;
	const char *sink_name;
	struct buffer_attr attr = { 0 };
	bool corked = false,
		no_remap = false,
		no_remix = false,
		fix_format = false,
		fix_rate = false,
		fix_channels = false,
		no_move = false,
		variable_rate = false,
		muted = false,
		adjust_latency = false,
		early_requests = false,
		dont_inhibit_auto_suspend = false,
		volume_set = true,
		muted_set = false,
		fail_on_suspend = false,
		relative_volume = false,
		passthrough = false;
	struct volume volume;
	struct pw_properties *props = NULL;
	uint8_t n_formats = 0;
	struct stream *stream = NULL;
	uint32_t n_params = 0, n_valid_formats = 0, flags;
	const struct spa_pod *params[MAX_FORMATS];
	uint8_t buffer[4096];
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));

	props = pw_properties_copy(client->props);
	if (props == NULL)
		goto error_errno;

	if (client->version < 13) {
		if ((res = message_get(m,
				TAG_STRING, &name,
				TAG_INVALID)) < 0)
			goto error_protocol;
		if (name == NULL)
			goto error_protocol;
	}
	if (message_get(m,
			TAG_SAMPLE_SPEC, &ss,
			TAG_CHANNEL_MAP, &map,
			TAG_U32, &sink_index,
			TAG_STRING, &sink_name,
			TAG_U32, &attr.maxlength,
			TAG_BOOLEAN, &corked,
			TAG_U32, &attr.tlength,
			TAG_U32, &attr.prebuf,
			TAG_U32, &attr.minreq,
			TAG_U32, &syncid,
			TAG_CVOLUME, &volume,
			TAG_INVALID) < 0)
		goto error_protocol;

	pw_log_info("[%s] CREATE_PLAYBACK_STREAM tag:%u corked:%u sink-name:%s sink-index:%u",
			client->name, tag, corked, sink_name, sink_index);

	if (sink_index != SPA_ID_INVALID && sink_name != NULL)
		goto error_invalid;

	if (client->version >= 12) {
		if (message_get(m,
				TAG_BOOLEAN, &no_remap,
				TAG_BOOLEAN, &no_remix,
				TAG_BOOLEAN, &fix_format,
				TAG_BOOLEAN, &fix_rate,
				TAG_BOOLEAN, &fix_channels,
				TAG_BOOLEAN, &no_move,
				TAG_BOOLEAN, &variable_rate,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 13) {
		if (message_get(m,
				TAG_BOOLEAN, &muted,
				TAG_BOOLEAN, &adjust_latency,
				TAG_PROPLIST, props,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 14) {
		if (message_get(m,
				TAG_BOOLEAN, &volume_set,
				TAG_BOOLEAN, &early_requests,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 15) {
		if (message_get(m,
				TAG_BOOLEAN, &muted_set,
				TAG_BOOLEAN, &dont_inhibit_auto_suspend,
				TAG_BOOLEAN, &fail_on_suspend,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 17) {
		if (message_get(m,
				TAG_BOOLEAN, &relative_volume,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 18) {
		if (message_get(m,
				TAG_BOOLEAN, &passthrough,
				TAG_INVALID) < 0)
			goto error_protocol;
	}

	if (client->version >= 21) {
		if (message_get(m,
				TAG_U8, &n_formats,
				TAG_INVALID) < 0)
			goto error_protocol;

		if (n_formats) {
			uint8_t i;
			for (i = 0; i < n_formats; i++) {
				struct format_info format;
				uint32_t r;

				if (message_get(m,
						TAG_FORMAT_INFO, &format,
						TAG_INVALID) < 0)
					goto error_protocol;

				if (n_params < MAX_FORMATS &&
				    (params[n_params] = format_info_build_param(&b,
						SPA_PARAM_EnumFormat, &format, &r)) != NULL) {
					n_params++;
					n_valid_formats++;
					if (r > rate)
						rate = r;
				} else {
					log_format_info(impl, SPA_LOG_LEVEL_WARN, &format);
				}
				format_info_clear(&format);
			}
		}
	}
	if (sample_spec_valid(&ss)) {
		if (fix_format || fix_rate || fix_channels) {
			struct sample_spec sfix = ss;
			if (fix_format)
				sfix.format = SPA_AUDIO_FORMAT_UNKNOWN;
			if (fix_rate)
				sfix.rate = 0;
			if (fix_channels)
				sfix.channels = 0;
			if (n_params < MAX_FORMATS &&
			    (params[n_params] = format_build_param(&b,
					SPA_PARAM_EnumFormat, &sfix,
					sfix.channels > 0 ? &map : NULL)) != NULL) {
				n_params++;
				n_valid_formats++;
			}
		}
		else if (n_params < MAX_FORMATS &&
		    (params[n_params] = format_build_param(&b,
				SPA_PARAM_EnumFormat, &ss,
				ss.channels > 0 ? &map : NULL)) != NULL) {
			n_params++;
			n_valid_formats++;
		} else {
			pw_log_warn("%p: unsupported format:%s rate:%d channels:%u",
					impl, format_id2name(ss.format), ss.rate,
					ss.channels);
		}
		rate = ss.rate;
	}

	if (m->offset != m->length)
		goto error_protocol;

	if (n_valid_formats == 0)
		goto error_no_formats;

	stream = stream_new(client, STREAM_TYPE_PLAYBACK, tag, &ss, &map, &attr);
	if (stream == NULL)
		goto error_errno;

	stream->corked = corked;
	stream->adjust_latency = adjust_latency;
	stream->early_requests = early_requests;
	stream->volume = volume;
	stream->volume_set = volume_set;
	stream->muted = muted;
	stream->muted_set = muted_set;
	stream->is_underrun = true;
	stream->underrun_for = -1;

	if (rate != 0) {
		struct spa_fraction lat;
		fix_playback_buffer_attr(stream, &attr, rate, &lat);
		pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", rate);
		pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%u",
				lat.num, lat.denom);
	}
	if (no_remix)
		pw_properties_set(props, PW_KEY_STREAM_DONT_REMIX, "true");
	flags = 0;
	if (no_move)
		flags |= PW_STREAM_FLAG_DONT_RECONNECT;

	if (sink_name != NULL) {
		pw_properties_set(props,
				PW_KEY_TARGET_OBJECT, sink_name);
	} else if (sink_index != SPA_ID_INVALID && sink_index != 0) {
		pw_properties_setf(props,
				PW_KEY_TARGET_OBJECT, "%u", sink_index);
	}

	stream->stream = pw_stream_new(client->core, name, props);
	props = NULL;
	if (stream->stream == NULL)
		goto error_errno;

	pw_log_debug("%p: new stream %p channel:%d passthrough:%d",
			impl, stream, stream->channel, passthrough);

	pw_stream_add_listener(stream->stream,
			&stream->stream_listener,
			&stream_events, stream);

	pw_stream_connect(stream->stream,
			PW_DIRECTION_OUTPUT,
			SPA_ID_INVALID,
			flags |
			PW_STREAM_FLAG_AUTOCONNECT |
			PW_STREAM_FLAG_RT_PROCESS |
			PW_STREAM_FLAG_MAP_BUFFERS,
			params, n_params);

	return 0;

error_errno:
	res = -errno;
	goto error;
error_protocol:
	res = -EPROTO;
	goto error;
error_no_formats:
	res = -ENOTSUP;
	goto error;
error_invalid:
	res = -EINVAL;
	goto error;
error:
	pw_properties_free(props);
	if (stream)
		stream_free(stream);
	return res;
}

static int do_create_record_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	const char *name = NULL;
	int res;
	struct sample_spec ss;
	struct channel_map map;
	uint32_t source_index;
	const char *source_name;
	struct buffer_attr attr = { 0 };
	bool corked = false,
		no_remap = false,
		no_remix = false,
		fix_format = false,
		fix_rate = false,
		fix_channels = false,
		no_move = false,
		variable_rate = false,
		peak_detect = false,
		adjust_latency = false,
		early_requests = false,
		dont_inhibit_auto_suspend = false,
		volume_set = true,
		muted = false,
		muted_set = false,
		fail_on_suspend = false,
		relative_volume = false,
		passthrough = false;
	uint32_t direct_on_input_idx = SPA_ID_INVALID;
	struct volume volume = VOLUME_INIT;
	struct pw_properties *props = NULL;
	uint8_t n_formats = 0;
	struct stream *stream = NULL;
	uint32_t n_params = 0, n_valid_formats = 0, flags, id, rate = 0;
	const struct spa_pod *params[MAX_FORMATS];
	uint8_t buffer[4096];
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));

	props = pw_properties_copy(client->props);
	if (props == NULL)
		goto error_errno;

	if (client->version < 13) {
		if (message_get(m,
				TAG_STRING, &name,
				TAG_INVALID) < 0)
			goto error_protocol;
		if (name == NULL)
			goto error_protocol;
	}
	if (message_get(m,
			TAG_SAMPLE_SPEC, &ss,
			TAG_CHANNEL_MAP, &map,
			TAG_U32, &source_index,
			TAG_STRING, &source_name,
			TAG_U32, &attr.maxlength,
			TAG_BOOLEAN, &corked,
			TAG_U32, &attr.fragsize,
			TAG_INVALID) < 0)
		goto error_protocol;

	pw_log_info("[%s] CREATE_RECORD_STREAM tag:%u corked:%u source-name:%s source-index:%u",
			client->name, tag, corked, source_name, source_index);

	if (source_index != SPA_ID_INVALID && source_name != NULL)
		goto error_invalid;

	if (client->version >= 12) {
		if (message_get(m,
				TAG_BOOLEAN, &no_remap,
				TAG_BOOLEAN, &no_remix,
				TAG_BOOLEAN, &fix_format,
				TAG_BOOLEAN, &fix_rate,
				TAG_BOOLEAN, &fix_channels,
				TAG_BOOLEAN, &no_move,
				TAG_BOOLEAN, &variable_rate,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 13) {
		if (message_get(m,
				TAG_BOOLEAN, &peak_detect,
				TAG_BOOLEAN, &adjust_latency,
				TAG_PROPLIST, props,
				TAG_U32, &direct_on_input_idx,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 14) {
		if (message_get(m,
				TAG_BOOLEAN, &early_requests,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 15) {
		if (message_get(m,
				TAG_BOOLEAN, &dont_inhibit_auto_suspend,
				TAG_BOOLEAN, &fail_on_suspend,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (client->version >= 22) {
		if (message_get(m,
				TAG_U8, &n_formats,
				TAG_INVALID) < 0)
			goto error_protocol;

		if (n_formats) {
			uint8_t i;
			for (i = 0; i < n_formats; i++) {
				struct format_info format;
				uint32_t r;

				if (message_get(m,
						TAG_FORMAT_INFO, &format,
						TAG_INVALID) < 0)
					goto error_protocol;

				if (n_params < MAX_FORMATS &&
				    (params[n_params] = format_info_build_param(&b,
						SPA_PARAM_EnumFormat, &format, &r)) != NULL) {
					n_params++;
					n_valid_formats++;
					if (r > rate)
						rate = r;
				} else {
					log_format_info(impl, SPA_LOG_LEVEL_WARN, &format);
				}
				format_info_clear(&format);
			}
		}
		if (message_get(m,
				TAG_CVOLUME, &volume,
				TAG_BOOLEAN, &muted,
				TAG_BOOLEAN, &volume_set,
				TAG_BOOLEAN, &muted_set,
				TAG_BOOLEAN, &relative_volume,
				TAG_BOOLEAN, &passthrough,
				TAG_INVALID) < 0)
			goto error_protocol;
	} else {
		volume_set = false;
	}
	if (sample_spec_valid(&ss)) {
		if (fix_format || fix_rate || fix_channels) {
			struct sample_spec sfix = ss;
			if (fix_format)
				sfix.format = SPA_AUDIO_FORMAT_UNKNOWN;
			if (fix_rate)
				sfix.rate = 0;
			if (fix_channels)
				sfix.channels = 0;
			if (n_params < MAX_FORMATS &&
			    (params[n_params] = format_build_param(&b,
					SPA_PARAM_EnumFormat, &sfix,
					sfix.channels > 0 ? &map : NULL)) != NULL) {
				n_params++;
				n_valid_formats++;
			}
		}
		else if (n_params < MAX_FORMATS &&
		    (params[n_params] = format_build_param(&b,
				SPA_PARAM_EnumFormat, &ss,
				ss.channels > 0 ? &map : NULL)) != NULL) {
			n_params++;
			n_valid_formats++;
		} else {
			pw_log_warn("%p: unsupported format:%s rate:%d channels:%u",
					impl, format_id2name(ss.format), ss.rate,
					ss.channels);
		}
		rate = ss.rate;
	}
	if (m->offset != m->length)
		goto error_protocol;

	if (n_valid_formats == 0)
		goto error_no_formats;

	stream = stream_new(client, STREAM_TYPE_RECORD, tag, &ss, &map, &attr);
	if (stream == NULL)
		goto error_errno;

	stream->corked = corked;
	stream->adjust_latency = adjust_latency;
	stream->early_requests = early_requests;
	stream->volume = volume;
	stream->volume_set = volume_set;
	stream->muted = muted;
	stream->muted_set = muted_set;

	if (client->quirks & QUIRK_REMOVE_CAPTURE_DONT_MOVE)
		no_move = false;

	if (rate != 0) {
		struct spa_fraction lat;
		fix_record_buffer_attr(stream, &attr, rate, &lat);
		pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", rate);
		pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%u",
				lat.num, lat.denom);
	}
	if (peak_detect)
		pw_properties_set(props, PW_KEY_STREAM_MONITOR, "true");
	if (no_remix)
		pw_properties_set(props, PW_KEY_STREAM_DONT_REMIX, "true");
	flags = 0;
	if (no_move)
		flags |= PW_STREAM_FLAG_DONT_RECONNECT;

	if (direct_on_input_idx != SPA_ID_INVALID) {
		source_index = direct_on_input_idx;
	} else if (source_name != NULL) {
		if ((id = atoi(source_name)) != 0)
			source_index = id;
	}
	if (source_index != SPA_ID_INVALID && source_index != 0) {
		pw_properties_setf(props,
				PW_KEY_TARGET_OBJECT, "%u", source_index);
	} else if (source_name != NULL) {
		if (spa_strendswith(source_name, ".monitor")) {
			pw_properties_setf(props,
					PW_KEY_TARGET_OBJECT,
					"%.*s", (int)strlen(source_name)-8, source_name);
			pw_properties_set(props,
					PW_KEY_STREAM_CAPTURE_SINK, "true");
		} else {
			pw_properties_set(props,
					PW_KEY_TARGET_OBJECT, source_name);
		}
	}

	stream->stream = pw_stream_new(client->core, name, props);
	props = NULL;
	if (stream->stream == NULL)
		goto error_errno;

	pw_stream_add_listener(stream->stream,
			&stream->stream_listener,
			&stream_events, stream);

	pw_stream_connect(stream->stream,
			PW_DIRECTION_INPUT,
			SPA_ID_INVALID,
			flags |
			PW_STREAM_FLAG_AUTOCONNECT |
			PW_STREAM_FLAG_RT_PROCESS |
			PW_STREAM_FLAG_MAP_BUFFERS,
			params, n_params);

	return 0;

error_errno:
	res = -errno;
	goto error;
error_protocol:
	res = -EPROTO;
	goto error;
error_no_formats:
	res = -ENOTSUP;
	goto error;
error_invalid:
	res = -EINVAL;
	goto error;
error:
	pw_properties_free(props);
	if (stream)
		stream_free(stream);
	return res;
}

static int do_delete_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel;
	struct stream *stream;
	int res;

	if ((res = message_get(m,
			TAG_U32, &channel,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] DELETE_STREAM tag:%u channel:%u",
			client->name, tag, channel);

	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL)
		return -ENOENT;
	if (command == COMMAND_DELETE_PLAYBACK_STREAM &&
	    stream->type != STREAM_TYPE_PLAYBACK)
		return -ENOENT;
	if (command == COMMAND_DELETE_RECORD_STREAM &&
	    stream->type != STREAM_TYPE_RECORD)
		return -ENOENT;
	if (command == COMMAND_DELETE_UPLOAD_STREAM &&
	    stream->type != STREAM_TYPE_UPLOAD)
		return -ENOENT;

	stream_free(stream);

	return reply_simple_ack(client, tag);
}

static int do_get_playback_latency(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct message *reply;
	uint32_t channel;
	struct timeval tv, now;
	struct stream *stream;
	int res;

	if ((res = message_get(m,
			TAG_U32, &channel,
			TAG_TIMEVAL, &tv,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_debug("%p: %s tag:%u channel:%u", impl, commands[command].name, tag, channel);
	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type != STREAM_TYPE_PLAYBACK)
		return -ENOENT;

	pw_log_debug("read:0x%"PRIx64" write:0x%"PRIx64" queued:%"PRIi64" delay:%"PRIi64
			" playing:%"PRIu64,
			stream->read_index, stream->write_index,
			stream->write_index - stream->read_index, stream->delay,
			stream->playing_for);

	gettimeofday(&now, NULL);

	reply = reply_new(client, tag);
	message_put(reply,
		TAG_USEC, stream->delay,	/* sink latency + queued samples */
		TAG_USEC, 0LL,			/* always 0 */
		TAG_BOOLEAN, stream->playing_for > 0 &&
				!stream->corked,	/* playing state */
		TAG_TIMEVAL, &tv,
		TAG_TIMEVAL, &now,
		TAG_S64, stream->write_index,
		TAG_S64, stream->read_index,
		TAG_INVALID);

	if (client->version >= 13) {
		message_put(reply,
			TAG_U64, stream->underrun_for,
			TAG_U64, stream->playing_for,
			TAG_INVALID);
	}
	return client_queue_message(client, reply);
}

static int do_get_record_latency(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct message *reply;
	uint32_t channel;
	struct timeval tv, now;
	struct stream *stream;
	int res;

	if ((res = message_get(m,
			TAG_U32, &channel,
			TAG_TIMEVAL, &tv,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_debug("%p: %s channel:%u", impl, commands[command].name, channel);
	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type != STREAM_TYPE_RECORD)
		return -ENOENT;

	pw_log_debug("read:0x%"PRIx64" write:0x%"PRIx64" queued:%"PRIi64" delay:%"PRIi64,
			stream->read_index, stream->write_index,
			stream->write_index - stream->read_index, stream->delay);


	gettimeofday(&now, NULL);
	reply = reply_new(client, tag);
	message_put(reply,
		TAG_USEC, 0LL,			/* monitor latency */
		TAG_USEC, stream->delay,	/* source latency + queued */
		TAG_BOOLEAN, !stream->corked,	/* playing state */
		TAG_TIMEVAL, &tv,
		TAG_TIMEVAL, &now,
		TAG_S64, stream->write_index,
		TAG_S64, stream->read_index,
		TAG_INVALID);

	return client_queue_message(client, reply);
}

static int do_create_upload_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	const char *name;
	struct sample_spec ss;
	struct channel_map map;
	struct pw_properties *props = NULL;
	uint32_t length;
	struct stream *stream = NULL;
	struct message *reply;
	int res;

	if ((props = pw_properties_copy(client->props)) == NULL)
		goto error_errno;

	if ((res = message_get(m,
			TAG_STRING, &name,
			TAG_SAMPLE_SPEC, &ss,
			TAG_CHANNEL_MAP, &map,
			TAG_U32, &length,
			TAG_INVALID)) < 0)
		goto error_proto;

	if (client->version >= 13) {
		if ((res = message_get(m,
				TAG_PROPLIST, props,
				TAG_INVALID)) < 0)
			goto error_proto;

	} else {
		pw_properties_set(props, PW_KEY_MEDIA_NAME, name);
	}
	if (name == NULL)
		name = pw_properties_get(props, "event.id");
	if (name == NULL)
		name = pw_properties_get(props, PW_KEY_MEDIA_NAME);

	if (name == NULL ||
	    !sample_spec_valid(&ss) ||
	    !channel_map_valid(&map) ||
	    ss.channels != map.channels ||
	    length == 0 || (length % sample_spec_frame_size(&ss) != 0))
		goto error_invalid;
	if (length >= SCACHE_ENTRY_SIZE_MAX)
		goto error_toolarge;

	pw_log_info("[%s] %s tag:%u name:%s length:%d",
			client->name, commands[command].name, tag,
			name, length);

	stream = stream_new(client, STREAM_TYPE_UPLOAD, tag, &ss, &map, &(struct buffer_attr) {
		.maxlength = length,
	});
	if (stream == NULL)
		goto error_errno;

	stream->props = props;

	stream->buffer = calloc(1, MAXLENGTH);
	if (stream->buffer == NULL)
		goto error_errno;

	reply = reply_new(client, tag);
	message_put(reply,
		TAG_U32, stream->channel,
		TAG_U32, length,
		TAG_INVALID);
	return client_queue_message(client, reply);

error_errno:
	res = -errno;
	goto error;
error_proto:
	res = -EPROTO;
	goto error;
error_invalid:
	res = -EINVAL;
	goto error;
error_toolarge:
	res = -EOVERFLOW;
	goto error;
error:
	pw_properties_free(props);
	if (stream)
		stream_free(stream);
	return res;
}

static int do_finish_upload_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	uint32_t channel, event;
	struct stream *stream;
	struct sample *sample;
	const char *name;
	int res;

	if (message_get(m,
			TAG_U32, &channel,
			TAG_INVALID) < 0)
		return -EPROTO;

	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type != STREAM_TYPE_UPLOAD)
		return -ENOENT;

	name = pw_properties_get(stream->props, "event.id");
	if (name == NULL)
		name = pw_properties_get(stream->props, PW_KEY_MEDIA_NAME);
	if (name == NULL)
		goto error_invalid;

	pw_log_info("[%s] %s tag:%u channel:%u name:%s",
			client->name, commands[command].name, tag,
			channel, name);

	struct sample *old = find_sample(impl, SPA_ID_INVALID, name);
	if (old == NULL || old->ref > 1) {
		sample = calloc(1, sizeof(*sample));
		if (sample == NULL)
			goto error_errno;

		if (old != NULL) {
			sample->index = old->index;
			spa_assert_se(pw_map_insert_at(&impl->samples, sample->index, sample) == 0);

			old->index = SPA_ID_INVALID;
			sample_unref(old);
		} else {
			sample->index = pw_map_insert_new(&impl->samples, sample);
			if (sample->index == SPA_ID_INVALID)
				goto error_errno;
		}
	} else {
		pw_properties_free(old->props);
		free(old->buffer);
		impl->stat.sample_cache -= old->length;

		sample = old;
	}

	if (old != NULL)
		event = SUBSCRIPTION_EVENT_CHANGE;
	else
		event = SUBSCRIPTION_EVENT_NEW;

	sample->ref = 1;
	sample->impl = impl;
	sample->name = name;
	sample->props = stream->props;
	sample->ss = stream->ss;
	sample->map = stream->map;
	sample->buffer = stream->buffer;
	sample->length = stream->attr.maxlength;

	impl->stat.sample_cache += sample->length;

	stream->props = NULL;
	stream->buffer = NULL;
	stream_free(stream);

	broadcast_subscribe_event(impl,
			SUBSCRIPTION_MASK_SAMPLE_CACHE,
			event | SUBSCRIPTION_EVENT_SAMPLE_CACHE,
			sample->index);

	return reply_simple_ack(client, tag);

error_errno:
	res = -errno;
	free(sample);
	goto error;
error_invalid:
	res = -EINVAL;
	goto error;
error:
	stream_free(stream);
	return res;
}

static const char *get_default(struct client *client, bool sink)
{
	struct selector sel;
	struct pw_manager *manager = client->manager;
	struct pw_manager_object *o;
	const char *def, *str, *mon;

	spa_zero(sel);
	if (sink) {
		sel.type = pw_manager_object_is_sink;
		sel.key = PW_KEY_NODE_NAME;
		sel.value = client->default_sink;
		def = DEFAULT_SINK;
	} else {
		sel.type = pw_manager_object_is_source_or_monitor;
		sel.key = PW_KEY_NODE_NAME;
		sel.value = client->default_source;
		def = DEFAULT_SOURCE;
	}
	sel.accumulate = select_best;

	o = select_object(manager, &sel);
	if (o == NULL || o->props == NULL)
		return def;
	str = pw_properties_get(o->props, PW_KEY_NODE_NAME);

	if (!sink && pw_manager_object_is_monitor(o)) {
		def = DEFAULT_MONITOR;
		if (str != NULL &&
		    (mon = pw_properties_get(o->props, PW_KEY_NODE_NAME".monitor")) == NULL) {
			pw_properties_setf(o->props,
					PW_KEY_NODE_NAME".monitor",
					"%s.monitor", str);
		}
		str = pw_properties_get(o->props, PW_KEY_NODE_NAME".monitor");
	}
	if (str == NULL)
		str = def;
	return str;
}

static struct pw_manager_object *find_device(struct client *client,
		uint32_t index, const char *name, bool sink, bool *is_monitor)
{
	struct selector sel;
	bool monitor = false, find_default = false;
	struct pw_manager_object *o;

	if (name != NULL) {
		if (spa_streq(name, DEFAULT_MONITOR)) {
			if (sink)
				return NULL;
			sink = true;
			find_default = true;
		} else if (spa_streq(name, DEFAULT_SOURCE)) {
			if (sink)
				return NULL;
			find_default = true;
		} else if (spa_streq(name, DEFAULT_SINK)) {
			if (!sink)
				return NULL;
			find_default = true;
		} else if (spa_atou32(name, &index, 0)) {
			name = NULL;
		}
	}
	if (name == NULL && (index == SPA_ID_INVALID || index == 0))
		find_default = true;

	if (find_default) {
		name = get_default(client, sink);
		index = SPA_ID_INVALID;
	}

	if (name != NULL) {
		if (spa_strendswith(name, ".monitor")) {
			name = strndupa(name, strlen(name)-8);
			monitor = true;
		}
	} else if (index == SPA_ID_INVALID)
		return NULL;


	spa_zero(sel);
	sel.type = sink ?
		pw_manager_object_is_sink :
		pw_manager_object_is_source_or_monitor;
	sel.index = index;
	sel.key = PW_KEY_NODE_NAME;
	sel.value = name;

	o = select_object(client->manager, &sel);
	if (o != NULL) {
		if (!sink && pw_manager_object_is_monitor(o))
			monitor = true;
	}
	if (is_monitor)
		*is_monitor = monitor;

	return o;
}

static void sample_play_finish(struct pending_sample *ps)
{
	struct client *client = ps->client;
	pending_sample_free(ps);
	client_unref(client);
}

static void sample_play_ready_reply(void *data, struct client *client, uint32_t tag)
{
	struct pending_sample *ps = data;
	struct message *reply;
	uint32_t index = id_to_index(client->manager, ps->play->id);

	pw_log_info("[%s] PLAY_SAMPLE tag:%u index:%u",
			client->name, ps->tag, index);

	ps->ready = true;

	reply = reply_new(client, ps->tag);
	if (client->version >= 13)
		message_put(reply,
			TAG_U32, index,
			TAG_INVALID);

	client_queue_message(client, reply);

	if (ps->done)
		sample_play_finish(ps);
}

static void sample_play_ready(void *data, uint32_t id)
{
	struct pending_sample *ps = data;
	struct client *client = ps->client;
	operation_new_cb(client, ps->tag, sample_play_ready_reply, ps);
}

static void on_sample_done(void *obj, void *data, int res, uint32_t id)
{
	struct pending_sample *ps = obj;
	ps->done = true;
	if (ps->ready)
		sample_play_finish(ps);
}

static void sample_play_done(void *data, int res)
{
	struct pending_sample *ps = data;
	struct client *client = ps->client;
	struct impl *impl = client->impl;

	if (res < 0)
		reply_error(client, COMMAND_PLAY_SAMPLE, ps->tag, res);
	else
		pw_log_info("[%s] PLAY_SAMPLE done tag:%u", client->name, ps->tag);

	pw_work_queue_add(impl->work_queue, ps, 0,
				on_sample_done, client);
}

static const struct sample_play_events sample_play_events = {
	VERSION_SAMPLE_PLAY_EVENTS,
	.ready = sample_play_ready,
	.done = sample_play_done,
};

static int do_play_sample(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	uint32_t sink_index, volume;
	struct sample *sample;
	struct sample_play *play;
	const char *sink_name, *name;
	struct pw_properties *props = NULL;
	struct pending_sample *ps;
	struct pw_manager_object *o;
	int res;

	if ((props = pw_properties_new(NULL, NULL)) == NULL)
		goto error_errno;

	if ((res = message_get(m,
			TAG_U32, &sink_index,
			TAG_STRING, &sink_name,
			TAG_U32, &volume,
			TAG_STRING, &name,
			TAG_INVALID)) < 0)
		goto error_proto;

	if (client->version >= 13) {
		if ((res = message_get(m,
				TAG_PROPLIST, props,
				TAG_INVALID)) < 0)
			goto error_proto;

	}
	pw_log_info("[%s] %s tag:%u sink_index:%u sink_name:%s name:%s",
			client->name, commands[command].name, tag,
			sink_index, sink_name, name);

	pw_properties_update(props, &client->props->dict);

	if (sink_index != SPA_ID_INVALID && sink_name != NULL)
		goto error_inval;

	o = find_device(client, sink_index, sink_name, PW_DIRECTION_OUTPUT, NULL);
	if (o == NULL)
		goto error_noent;

	sample = find_sample(impl, SPA_ID_INVALID, name);
	if (sample == NULL)
		goto error_noent;

	pw_properties_setf(props, PW_KEY_TARGET_OBJECT, "%"PRIu64, o->serial);

	play = sample_play_new(client->core, sample, props, sizeof(struct pending_sample));
	props = NULL;
	if (play == NULL)
		goto error_errno;

	ps = play->user_data;
	ps->client = client;
	ps->play = play;
	ps->tag = tag;
	sample_play_add_listener(play, &ps->listener, &sample_play_events, ps);
	spa_list_append(&client->pending_samples, &ps->link);
	client->ref++;

	return 0;

error_errno:
	res = -errno;
	goto error;
error_proto:
	res = -EPROTO;
	goto error;
error_inval:
	res = -EINVAL;
	goto error;
error_noent:
	res = -ENOENT;
	goto error;
error:
	pw_properties_free(props);
	return res;
}

static int do_remove_sample(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	const char *name;
	struct sample *sample;
	int res;

	if ((res = message_get(m,
			TAG_STRING, &name,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u name:%s",
			client->name, commands[command].name, tag,
			name);
	if (name == NULL)
		return -EINVAL;
	if ((sample = find_sample(impl, SPA_ID_INVALID, name)) == NULL)
		return -ENOENT;

	broadcast_subscribe_event(impl,
			SUBSCRIPTION_MASK_SAMPLE_CACHE,
			SUBSCRIPTION_EVENT_REMOVE |
			SUBSCRIPTION_EVENT_SAMPLE_CACHE,
			sample->index);

	pw_map_remove(&impl->samples, sample->index);
	sample->index = SPA_ID_INVALID;

	sample_unref(sample);

	return reply_simple_ack(client, tag);
}

static int do_cork_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel;
	bool cork;
	struct stream *stream;
	int res;

	if ((res = message_get(m,
			TAG_U32, &channel,
			TAG_BOOLEAN, &cork,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u channel:%u cork:%s",
			client->name, commands[command].name, tag,
			channel, cork ? "yes" : "no");

	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type == STREAM_TYPE_UPLOAD)
		return -ENOENT;

	stream->corked = cork;
	stream_set_paused(stream, cork, "cork request");
	if (cork) {
		stream->is_underrun = true;
	} else {
		stream->playing_for = 0;
		stream->underrun_for = -1;
		stream_send_request(stream);
	}

	return reply_simple_ack(client, tag);
}

static int do_flush_trigger_prebuf_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel;
	struct stream *stream;
	int res;

	if ((res = message_get(m,
			TAG_U32, &channel,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u channel:%u",
			client->name, commands[command].name, tag, channel);

	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type == STREAM_TYPE_UPLOAD)
		return -ENOENT;

	switch (command) {
	case COMMAND_FLUSH_PLAYBACK_STREAM:
	case COMMAND_FLUSH_RECORD_STREAM:
		stream_flush(stream);
		break;
	case COMMAND_TRIGGER_PLAYBACK_STREAM:
	case COMMAND_PREBUF_PLAYBACK_STREAM:
		if (stream->type != STREAM_TYPE_PLAYBACK)
			return -ENOENT;
		if (command == COMMAND_TRIGGER_PLAYBACK_STREAM)
			stream->in_prebuf = false;
		else if (stream->attr.prebuf > 0)
			stream->in_prebuf = true;
		stream_send_request(stream);
		break;
	default:
		return -EINVAL;
	}
	return reply_simple_ack(client, tag);
}

static int set_node_volume_mute(struct pw_manager_object *o,
		struct volume *vol, bool *mute, bool is_monitor)
{
	char buf[1024];
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
	struct spa_pod_frame f[1];
	struct spa_pod *param;
	uint32_t volprop, muteprop;

	if (!SPA_FLAG_IS_SET(o->permissions, PW_PERM_W | PW_PERM_X))
		return -EACCES;
	if (o->proxy == NULL)
		return -ENOENT;

	if (is_monitor) {
		volprop = SPA_PROP_monitorVolumes;
		muteprop = SPA_PROP_monitorMute;
	} else {
		volprop = SPA_PROP_channelVolumes;
		muteprop = SPA_PROP_mute;
	}

	spa_pod_builder_push_object(&b, &f[0],
			SPA_TYPE_OBJECT_Props,  SPA_PARAM_Props);
	if (vol)
		spa_pod_builder_add(&b,
				volprop, SPA_POD_Array(sizeof(float),
							SPA_TYPE_Float,
							vol->channels,
							vol->values), 0);
	if (mute)
		spa_pod_builder_add(&b,
				muteprop, SPA_POD_Bool(*mute), 0);
	param = spa_pod_builder_pop(&b, &f[0]);

	pw_node_set_param((struct pw_node*)o->proxy,
		SPA_PARAM_Props, 0, param);
	return 0;
}

static int set_card_volume_mute_delay(struct pw_manager_object *o, uint32_t port_index,
		uint32_t device_id, struct volume *vol, bool *mute, int64_t *latency_offset)
{
	char buf[1024];
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
	struct spa_pod_frame f[2];
	struct spa_pod *param;

	if (!SPA_FLAG_IS_SET(o->permissions, PW_PERM_W | PW_PERM_X))
		return -EACCES;

	if (o->proxy == NULL)
		return -ENOENT;

	spa_pod_builder_push_object(&b, &f[0],
			SPA_TYPE_OBJECT_ParamRoute, SPA_PARAM_Route);
	spa_pod_builder_add(&b,
			SPA_PARAM_ROUTE_index, SPA_POD_Int(port_index),
			SPA_PARAM_ROUTE_device, SPA_POD_Int(device_id),
			0);
	spa_pod_builder_prop(&b, SPA_PARAM_ROUTE_props, 0);
	spa_pod_builder_push_object(&b, &f[1],
			SPA_TYPE_OBJECT_Props,  SPA_PARAM_Props);
	if (vol)
		spa_pod_builder_add(&b,
				SPA_PROP_channelVolumes, SPA_POD_Array(sizeof(float),
								SPA_TYPE_Float,
								vol->channels,
								vol->values), 0);
	if (mute)
		spa_pod_builder_add(&b,
				SPA_PROP_mute, SPA_POD_Bool(*mute), 0);
	if (latency_offset)
		spa_pod_builder_add(&b,
				SPA_PROP_latencyOffsetNsec, SPA_POD_Long(*latency_offset), 0);
	spa_pod_builder_pop(&b, &f[1]);
	spa_pod_builder_prop(&b, SPA_PARAM_ROUTE_save, 0);
	spa_pod_builder_bool(&b, true);
	param = spa_pod_builder_pop(&b, &f[0]);

	pw_device_set_param((struct pw_device*)o->proxy,
			SPA_PARAM_Route, 0, param);
	return 0;
}

static int set_card_port(struct pw_manager_object *o, uint32_t device_id,
		uint32_t port_index)
{
	char buf[1024];
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));

	if (!SPA_FLAG_IS_SET(o->permissions, PW_PERM_W | PW_PERM_X))
		return -EACCES;

	if (o->proxy == NULL)
		return -ENOENT;

	pw_device_set_param((struct pw_device*)o->proxy,
			SPA_PARAM_Route, 0,
			spa_pod_builder_add_object(&b,
				SPA_TYPE_OBJECT_ParamRoute, SPA_PARAM_Route,
				SPA_PARAM_ROUTE_index, SPA_POD_Int(port_index),
				SPA_PARAM_ROUTE_device, SPA_POD_Int(device_id),
				SPA_PARAM_ROUTE_save, SPA_POD_Bool(true)));

	return 0;
}

static int do_set_stream_volume(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	uint32_t index;
	struct stream *stream;
	struct volume volume;
	int res;

	if ((res = message_get(m,
			TAG_U32, &index,
			TAG_CVOLUME, &volume,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u",
			client->name, commands[command].name, tag, index);

	stream = find_stream(client, index);
	if (stream != NULL) {

		if (volume_compare(&stream->volume, &volume) == 0)
			goto done;

		pw_stream_set_control(stream->stream,
				SPA_PROP_channelVolumes, volume.channels, volume.values,
				0);
	} else {
		struct selector sel;
		struct pw_manager_object *o;

		spa_zero(sel);
		sel.index = index;
		if (command == COMMAND_SET_SINK_INPUT_VOLUME)
			sel.type = pw_manager_object_is_sink_input;
		else
			sel.type = pw_manager_object_is_source_output;

		o = select_object(manager, &sel);
		if (o == NULL)
			return -ENOENT;

		if ((res = set_node_volume_mute(o, &volume, NULL, false)) < 0)
			return res;
	}
done:
	return operation_new(client, tag);
}

static int do_set_stream_mute(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	uint32_t index;
	struct stream *stream;
	int res;
	bool mute;

	if ((res = message_get(m,
			TAG_U32, &index,
			TAG_BOOLEAN, &mute,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] DO_SET_STREAM_MUTE tag:%u index:%u mute:%u",
			client->name, tag, index, mute);

	stream = find_stream(client, index);
	if (stream != NULL) {
		float val;

		if (stream->muted == mute)
			goto done;

		val = mute ? 1.0f : 0.0f;
		pw_stream_set_control(stream->stream,
				SPA_PROP_mute, 1, &val,
				0);
	} else {
		struct selector sel;
		struct pw_manager_object *o;

		spa_zero(sel);
		sel.index = index;
		if (command == COMMAND_SET_SINK_INPUT_MUTE)
			sel.type = pw_manager_object_is_sink_input;
		else
			sel.type = pw_manager_object_is_source_output;

		o = select_object(manager, &sel);
		if (o == NULL)
			return -ENOENT;

		if ((res = set_node_volume_mute(o, NULL, &mute, false)) < 0)
			return res;
	}
done:
	return operation_new(client, tag);
}

static int do_set_volume(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct pw_manager *manager = client->manager;
	struct pw_node_info *info;
	uint32_t index, card_id = SPA_ID_INVALID;
	const char *name, *str;
	struct volume volume;
	struct pw_manager_object *o, *card = NULL;
	int res;
	struct device_info dev_info;
	enum pw_direction direction;
	bool is_monitor;

	if ((res = message_get(m,
			TAG_U32, &index,
			TAG_STRING, &name,
			TAG_CVOLUME, &volume,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u name:%s",
			client->name, commands[command].name, tag, index, name);

	if ((index == SPA_ID_INVALID && name == NULL) ||
	    (index != SPA_ID_INVALID && name != NULL))
		return -EINVAL;

	if (command == COMMAND_SET_SINK_VOLUME)
		direction = PW_DIRECTION_OUTPUT;
	else
		direction = PW_DIRECTION_INPUT;

	o = find_device(client, index, name, direction == PW_DIRECTION_OUTPUT, &is_monitor);
	if (o == NULL || (info = o->info) == NULL || info->props == NULL)
		return -ENOENT;

	dev_info = DEVICE_INFO_INIT(direction);

	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_ID)) != NULL)
		card_id = (uint32_t)atoi(str);
	if ((str = spa_dict_lookup(info->props, "card.profile.device")) != NULL)
		dev_info.device = (uint32_t)atoi(str);
	if (card_id != SPA_ID_INVALID) {
		struct selector sel = { .id = card_id, .type = pw_manager_object_is_card, };
		card = select_object(manager, &sel);
	}
	collect_device_info(o, card, &dev_info, is_monitor, &impl->defs);

	if (dev_info.have_volume &&
	    volume_compare(&dev_info.volume_info.volume, &volume) == 0)
		goto done;

	if (card != NULL && !is_monitor && dev_info.active_port != SPA_ID_INVALID)
		res = set_card_volume_mute_delay(card, dev_info.active_port,
				dev_info.device, &volume, NULL, NULL);
	else
		res = set_node_volume_mute(o, &volume, NULL, is_monitor);

	if (res < 0)
		return res;

done:
	return operation_new(client, tag);
}

static int do_set_mute(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct pw_manager *manager = client->manager;
	struct pw_node_info *info;
	uint32_t index, card_id = SPA_ID_INVALID;
	const char *name, *str;
	bool mute;
	struct pw_manager_object *o, *card = NULL;
	int res;
	struct device_info dev_info;
	enum pw_direction direction;
	bool is_monitor;

	if ((res = message_get(m,
			TAG_U32, &index,
			TAG_STRING, &name,
			TAG_BOOLEAN, &mute,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u name:%s mute:%d",
			client->name, commands[command].name, tag, index, name, mute);

	if ((index == SPA_ID_INVALID && name == NULL) ||
	    (index != SPA_ID_INVALID && name != NULL))
		return -EINVAL;

	if (command == COMMAND_SET_SINK_MUTE)
		direction = PW_DIRECTION_OUTPUT;
	else
		direction = PW_DIRECTION_INPUT;

	o = find_device(client, index, name, direction == PW_DIRECTION_OUTPUT, &is_monitor);
	if (o == NULL || (info = o->info) == NULL || info->props == NULL)
		return -ENOENT;

	dev_info = DEVICE_INFO_INIT(direction);

	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_ID)) != NULL)
		card_id = (uint32_t)atoi(str);
	if ((str = spa_dict_lookup(info->props, "card.profile.device")) != NULL)
		dev_info.device = (uint32_t)atoi(str);
	if (card_id != SPA_ID_INVALID) {
		struct selector sel = { .id = card_id, .type = pw_manager_object_is_card, };
		card = select_object(manager, &sel);
	}
	collect_device_info(o, card, &dev_info, is_monitor, &impl->defs);

	if (dev_info.have_volume &&
	    dev_info.volume_info.mute == mute)
		goto done;

	if (card != NULL && !is_monitor && dev_info.active_port != SPA_ID_INVALID)
		res = set_card_volume_mute_delay(card, dev_info.active_port,
				dev_info.device, NULL, &mute, NULL);
	else
		res = set_node_volume_mute(o, NULL, &mute, is_monitor);

	if (res < 0)
		return res;
done:
	return operation_new(client, tag);
}

static int do_set_port(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	struct pw_node_info *info;
	uint32_t index, card_id = SPA_ID_INVALID, device_id = SPA_ID_INVALID;
	uint32_t port_index = SPA_ID_INVALID;
	const char *name, *str, *port_name;
	struct pw_manager_object *o, *card = NULL;
	int res;
	enum pw_direction direction;

	if ((res = message_get(m,
			TAG_U32, &index,
			TAG_STRING, &name,
			TAG_STRING, &port_name,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u name:%s port:%s",
			client->name, commands[command].name, tag, index, name, port_name);

	if ((index == SPA_ID_INVALID && name == NULL) ||
	    (index != SPA_ID_INVALID && name != NULL))
		return -EINVAL;

	if (command == COMMAND_SET_SINK_PORT)
		direction = PW_DIRECTION_OUTPUT;
	else
		direction = PW_DIRECTION_INPUT;

	o = find_device(client, index, name, direction == PW_DIRECTION_OUTPUT, NULL);
	if (o == NULL || (info = o->info) == NULL || info->props == NULL)
		return -ENOENT;

	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_ID)) != NULL)
		card_id = (uint32_t)atoi(str);
	if ((str = spa_dict_lookup(info->props, "card.profile.device")) != NULL)
		device_id = (uint32_t)atoi(str);
	if (card_id != SPA_ID_INVALID) {
		struct selector sel = { .id = card_id, .type = pw_manager_object_is_card, };
		card = select_object(manager, &sel);
	}
	if (card == NULL || device_id == SPA_ID_INVALID)
		return -ENOENT;

	port_index = find_port_index(card, direction, port_name);
	if (port_index == SPA_ID_INVALID)
		return -ENOENT;

	if ((res = set_card_port(card, device_id, port_index)) < 0)
		return res;

	return operation_new(client, tag);
}

static int do_set_port_latency_offset(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	const char *port_name = NULL;
	struct pw_manager_object *card;
	struct selector sel;
	struct card_info card_info = CARD_INFO_INIT;
	struct port_info *port_info;
	int64_t offset;
	int64_t value;
	int res;
	uint32_t n_ports;
	size_t i;

	spa_zero(sel);
	sel.key = PW_KEY_DEVICE_NAME;
	sel.type = pw_manager_object_is_card;

	if ((res = message_get(m,
			TAG_U32, &sel.index,
			TAG_STRING, &sel.value,
			TAG_STRING, &port_name,
			TAG_S64, &offset,
			TAG_INVALID)) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u card_name:%s port_name:%s offset:%"PRIi64,
			client->name, commands[command].name, tag, sel.index, sel.value, port_name, offset);

	if ((sel.index == SPA_ID_INVALID && sel.value == NULL) ||
	    (sel.index != SPA_ID_INVALID && sel.value != NULL))
		return -EINVAL;
	if (port_name == NULL)
		return -EINVAL;

	value = offset * 1000;  /* to nsec */

	if ((card = select_object(manager, &sel)) == NULL)
		return -ENOENT;

	collect_card_info(card, &card_info);
	port_info = alloca(card_info.n_ports * sizeof(*port_info));
	card_info.active_profile = SPA_ID_INVALID;
	n_ports = collect_port_info(card, &card_info, NULL, port_info);

	/* Set offset on all devices of the port */
	res = -ENOENT;
	for (i = 0; i < n_ports; i++) {
		struct port_info *pi = &port_info[i];
		size_t j;

		if (!spa_streq(pi->name, port_name))
			continue;

		res = 0;
		for (j = 0; j < pi->n_devices; ++j) {
			res = set_card_volume_mute_delay(card, pi->index, pi->devices[j], NULL, NULL, &value);
			if (res < 0)
				break;
		}

		if (res < 0)
			break;

		return operation_new(client, tag);
	}

	return res;
}

static int do_set_stream_name(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel;
	struct stream *stream;
	const char *name = NULL;
	struct spa_dict_item items[1];
	int res;

	if ((res = message_get(m,
			TAG_U32, &channel,
			TAG_STRING, &name,
			TAG_INVALID)) < 0)
		return -EPROTO;

	if (name == NULL)
		return -EINVAL;

	pw_log_info("[%s] SET_STREAM_NAME tag:%u channel:%d name:%s",
			client->name, tag, channel, name);

	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type == STREAM_TYPE_UPLOAD)
		return -ENOENT;

	items[0] = SPA_DICT_ITEM_INIT(PW_KEY_MEDIA_NAME, name);
	pw_stream_update_properties(stream->stream,
			&SPA_DICT_INIT(items, 1));

	return reply_simple_ack(client, tag);
}

static int do_update_proplist(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel, mode;
	struct stream *stream;
	struct pw_properties *props;
	int res;

	props = pw_properties_new(NULL, NULL);
	if (props == NULL)
		return -errno;

	if (command != COMMAND_UPDATE_CLIENT_PROPLIST) {
		if (message_get(m,
				TAG_U32, &channel,
				TAG_INVALID) < 0)
			goto error_protocol;
	} else {
		channel = SPA_ID_INVALID;
	}

	pw_log_info("[%s] %s tag:%u channel:%d",
			client->name, commands[command].name, tag, channel);

	if (message_get(m,
			TAG_U32, &mode,
			TAG_PROPLIST, props,
			TAG_INVALID) < 0)
		goto error_protocol;

	if (command != COMMAND_UPDATE_CLIENT_PROPLIST) {
		stream = pw_map_lookup(&client->streams, channel);
		if (stream == NULL || stream->type == STREAM_TYPE_UPLOAD)
			goto error_noentity;

		pw_stream_update_properties(stream->stream, &props->dict);
	} else {
		if (pw_properties_update(client->props, &props->dict) > 0) {
			client_update_quirks(client);
			client->name = pw_properties_get(client->props, PW_KEY_APP_NAME);
			pw_core_update_properties(client->core, &client->props->dict);
		}
	}
	res = reply_simple_ack(client, tag);
exit:
	pw_properties_free(props);
	return res;

error_protocol:
	res = -EPROTO;
	goto exit;
error_noentity:
	res = -ENOENT;
	goto exit;
}

static int do_remove_proplist(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t i, channel;
	struct stream *stream;
	struct pw_properties *props;
	struct spa_dict dict;
	struct spa_dict_item *items;
	int res;

	props = pw_properties_new(NULL, NULL);
	if (props == NULL)
		return -errno;

	if (command != COMMAND_REMOVE_CLIENT_PROPLIST) {
		if (message_get(m,
				TAG_U32, &channel,
				TAG_INVALID) < 0)
			goto error_protocol;
	} else {
		channel = SPA_ID_INVALID;
	}

	pw_log_info("[%s] %s tag:%u channel:%d",
			client->name, commands[command].name, tag, channel);

	while (true) {
		const char *key;

		if (message_get(m,
				TAG_STRING, &key,
				TAG_INVALID) < 0)
			goto error_protocol;
		if (key == NULL)
			break;
		pw_properties_set(props, key, key);
	}

	dict.n_items = props->dict.n_items;
	dict.items = items = alloca(sizeof(struct spa_dict_item) * dict.n_items);
	for (i = 0; i < dict.n_items; i++) {
		items[i].key = props->dict.items[i].key;
		items[i].value = NULL;
	}

	if (command != COMMAND_UPDATE_CLIENT_PROPLIST) {
		stream = pw_map_lookup(&client->streams, channel);
		if (stream == NULL || stream->type == STREAM_TYPE_UPLOAD)
			goto error_noentity;

		pw_stream_update_properties(stream->stream, &dict);
	} else {
		pw_core_update_properties(client->core, &dict);
	}
	res = reply_simple_ack(client, tag);
exit:
	pw_properties_free(props);
	return res;

error_protocol:
	res = -EPROTO;
	goto exit;
error_noentity:
	res = -ENOENT;
	goto exit;
}


static int do_get_server_info(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct pw_manager *manager = client->manager;
	struct pw_core_info *info = manager ? manager->info : NULL;
	char name[256];
	struct message *reply;

	pw_log_info("[%s] GET_SERVER_INFO tag:%u", client->name, tag);

	snprintf(name, sizeof(name), "PulseAudio (on PipeWire %s)", pw_get_library_version());

	reply = reply_new(client, tag);
	message_put(reply,
		TAG_STRING, name,
		TAG_STRING, "15.0.0",
		TAG_STRING, pw_get_user_name(),
		TAG_STRING, pw_get_host_name(),
		TAG_SAMPLE_SPEC, &impl->defs.sample_spec,
		TAG_STRING, manager ? get_default(client, true) : "",	/* default sink name */
		TAG_STRING, manager ? get_default(client, false) : "",	/* default source name */
		TAG_U32, info ? info->cookie : 0,			/* cookie */
		TAG_INVALID);

	if (client->version >= 15) {
		message_put(reply,
			TAG_CHANNEL_MAP, &impl->defs.channel_map,
			TAG_INVALID);
	}
	return client_queue_message(client, reply);
}

static int do_stat(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct message *reply;

	pw_log_info("[%s] STAT tag:%u", client->name, tag);

	reply = reply_new(client, tag);
	message_put(reply,
		TAG_U32, impl->stat.n_allocated,	/* n_allocated */
		TAG_U32, impl->stat.allocated,		/* allocated size */
		TAG_U32, impl->stat.n_accumulated,	/* n_accumulated */
		TAG_U32, impl->stat.accumulated,	/* accumulated_size */
		TAG_U32, impl->stat.sample_cache,	/* sample cache size */
		TAG_INVALID);

	return client_queue_message(client, reply);
}

static int do_lookup(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct message *reply;
	struct pw_manager_object *o;
	const char *name;
	bool is_sink = command == COMMAND_LOOKUP_SINK;
	bool is_monitor;

	if (message_get(m,
			TAG_STRING, &name,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] LOOKUP tag:%u name:'%s'", client->name, tag, name);

	if ((o = find_device(client, SPA_ID_INVALID, name, is_sink, &is_monitor)) == NULL)
		return -ENOENT;

	reply = reply_new(client, tag);
	message_put(reply,
		TAG_U32, o->index,
		TAG_INVALID);

	return client_queue_message(client, reply);
}

static int do_drain_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel;
	struct stream *stream;

	if (message_get(m,
			TAG_U32, &channel,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] DRAIN tag:%u channel:%d", client->name, tag, channel);
	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type != STREAM_TYPE_PLAYBACK)
		return -ENOENT;

	stream->drain_tag = tag;
	stream->draining = true;
	stream_set_paused(stream, false, "drain start");

	return 0;
}

static int fill_client_info(struct client *client, struct message *m,
		struct pw_manager_object *o)
{
	struct pw_client_info *info = o->info;
	struct pw_manager *manager = client->manager;
	const char *str;
	uint32_t module_id = SPA_ID_INVALID;

	if (!pw_manager_object_is_client(o) || info == NULL || info->props == NULL)
		return -ENOENT;

	if ((str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID)) != NULL)
		module_id = (uint32_t)atoi(str);

	message_put(m,
		TAG_U32, o->index,				/* client index */
		TAG_STRING, pw_properties_get(o->props, PW_KEY_APP_NAME),
		TAG_U32, id_to_index(manager, module_id),	/* module index */
		TAG_STRING, "PipeWire",				/* driver */
		TAG_INVALID);
	if (client->version >= 13) {
		message_put(m,
			TAG_PROPLIST, info->props,
			TAG_INVALID);
	}
	return 0;
}

static int fill_module_info(struct client *client, struct message *m,
		struct pw_manager_object *o)
{
	struct pw_module_info *info = o->info;

	if (!pw_manager_object_is_module(o) || info == NULL || info->props == NULL)
		return -ENOENT;

	message_put(m,
		TAG_U32, o->index,			/* module index */
		TAG_STRING, info->name,
		TAG_STRING, info->args,
		TAG_U32, -1,				/* n_used */
		TAG_INVALID);

	if (client->version < 15) {
		message_put(m,
			TAG_BOOLEAN, false,		/* auto unload deprecated */
			TAG_INVALID);
	}
	if (client->version >= 15) {
		message_put(m,
			TAG_PROPLIST, info->props,
			TAG_INVALID);
	}
	return 0;
}

static int fill_ext_module_info(struct client *client, struct message *m,
		struct module *module)
{
	message_put(m,
		TAG_U32, module->index,			/* module index */
		TAG_STRING, module->info->name,
		TAG_STRING, module->args,
		TAG_U32, -1,				/* n_used */
		TAG_INVALID);

	if (client->version < 15) {
		message_put(m,
			TAG_BOOLEAN, false,		/* auto unload deprecated */
			TAG_INVALID);
	}
	if (client->version >= 15) {
		message_put(m,
			TAG_PROPLIST, module->info->properties,
			TAG_INVALID);
	}
	return 0;
}

static int64_t get_port_latency_offset(struct client *client, struct pw_manager_object *card, struct port_info *pi)
{
	struct pw_manager *m = client->manager;
	struct pw_manager_object *o;
	size_t j;

	/*
	 * The latency offset is a property of nodes in PipeWire, so we look it up on the
	 * nodes. We'll return the latency offset of the first node in the port.
	 *
	 * This is also because we need to be consistent with
	 * send_latency_offset_subscribe_event, which sends events on node changes. The
	 * route data might not be updated yet when these events arrive.
	 */
	for (j = 0; j < pi->n_devices; ++j) {
		spa_list_for_each(o, &m->object_list, link) {
			const char *str;
			uint32_t card_id = SPA_ID_INVALID;
			uint32_t device_id = SPA_ID_INVALID;
			struct pw_node_info *info;

			if (o->creating || o->removing)
				continue;
			if (!pw_manager_object_is_sink(o) && !pw_manager_object_is_source_or_monitor(o))
				continue;
			if ((info = o->info) == NULL || info->props == NULL)
				continue;
			if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_ID)) != NULL)
				card_id = (uint32_t)atoi(str);
			if (card_id != card->id)
				continue;

			if ((str = spa_dict_lookup(info->props, "card.profile.device")) != NULL)
				device_id = (uint32_t)atoi(str);

			if (device_id == pi->devices[j])
				return get_node_latency_offset(o);
		}
	}

	return 0LL;
}

static int fill_card_info(struct client *client, struct message *m,
		struct pw_manager_object *o)
{
	struct pw_manager *manager = client->manager;
	struct pw_device_info *info = o->info;
	const char *str, *drv_name;
	uint32_t module_id = SPA_ID_INVALID, n_profiles, n;
	struct card_info card_info = CARD_INFO_INIT;
	struct profile_info *profile_info;

	if (!pw_manager_object_is_card(o) || info == NULL || info->props == NULL)
		return -ENOENT;

	if ((str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID)) != NULL)
		module_id = (uint32_t)atoi(str);

	drv_name = spa_dict_lookup(info->props, PW_KEY_DEVICE_API);
	if (drv_name && spa_streq("bluez5", drv_name))
		drv_name = "module-bluez5-device.c"; /* blueman needs this */

	message_put(m,
		TAG_U32, o->index,			/* card index */
		TAG_STRING, spa_dict_lookup(info->props, PW_KEY_DEVICE_NAME),
		TAG_U32, id_to_index(manager, module_id),
		TAG_STRING, drv_name,
		TAG_INVALID);

	collect_card_info(o, &card_info);

	message_put(m,
		TAG_U32, card_info.n_profiles,			/* n_profiles */
		TAG_INVALID);

	profile_info = alloca(card_info.n_profiles * sizeof(*profile_info));
	n_profiles = collect_profile_info(o, &card_info, profile_info);

	for (n = 0; n < n_profiles; n++) {
		struct profile_info *pi = &profile_info[n];

		message_put(m,
			TAG_STRING, pi->name,			/* profile name */
			TAG_STRING, pi->description,		/* profile description */
			TAG_U32, pi->n_sinks,			/* n_sinks */
			TAG_U32, pi->n_sources,			/* n_sources */
			TAG_U32, pi->priority,			/* priority */
			TAG_INVALID);

		if (client->version >= 29) {
			message_put(m,
				TAG_U32, pi->available != SPA_PARAM_AVAILABILITY_no,		/* available */
				TAG_INVALID);
		}
	}
	message_put(m,
		TAG_STRING, card_info.active_profile_name,	/* active profile name */
		TAG_PROPLIST, info->props,
		TAG_INVALID);

	if (client->version >= 26) {
		uint32_t n_ports;
		struct port_info *port_info, *pi;

		port_info = alloca(card_info.n_ports * sizeof(*port_info));
		card_info.active_profile = SPA_ID_INVALID;
		n_ports = collect_port_info(o, &card_info, NULL, port_info);

		message_put(m,
			TAG_U32, n_ports,				/* n_ports */
			TAG_INVALID);

		for (n = 0; n < n_ports; n++) {
			struct spa_dict_item *items;
			struct spa_dict *pdict = NULL, dict;
			uint32_t i, pi_n_profiles;

			pi = &port_info[n];

			if (pi->info && pi->n_props > 0) {
				items = alloca(pi->n_props * sizeof(*items));
				dict.items = items;
				pdict = collect_props(pi->info, &dict);
			}

			message_put(m,
				TAG_STRING, pi->name,			/* port name */
				TAG_STRING, pi->description,		/* port description */
				TAG_U32, pi->priority,			/* port priority */
				TAG_U32, pi->available,			/* port available */
				TAG_U8, pi->direction == SPA_DIRECTION_INPUT ? 2 : 1,	/* port direction */
				TAG_PROPLIST, pdict,			/* port proplist */
				TAG_INVALID);

			pi_n_profiles = SPA_MIN(pi->n_profiles, n_profiles);
			if (pi->n_profiles != pi_n_profiles) {
				/* libpulse assumes port profile array size <= n_profiles */
				pw_log_error("%p: card %d port %d profiles inconsistent (%d < %d)",
						client->impl, o->id, n, n_profiles, pi->n_profiles);
			}

			message_put(m,
				TAG_U32, pi_n_profiles,		/* n_profiles */
				TAG_INVALID);

			for (i = 0; i < pi_n_profiles; i++) {
				uint32_t j;
				const char *name = "off";

				for (j = 0; j < n_profiles; ++j) {
					if (profile_info[j].index == pi->profiles[i]) {
						name = profile_info[j].name;
						break;
					}
				}

				message_put(m,
					TAG_STRING, name,	/* profile name */
					TAG_INVALID);
			}
			if (client->version >= 27) {
				int64_t latency_offset = get_port_latency_offset(client, o, pi);
				message_put(m,
					TAG_S64, latency_offset / 1000,	/* port latency offset */
					TAG_INVALID);
			}
			if (client->version >= 34) {
				message_put(m,
					TAG_STRING, pi->availability_group,	/* available group */
					TAG_U32, pi->type,		/* port type */
					TAG_INVALID);
			}
		}
	}
	return 0;
}

static int fill_sink_info_proplist(struct message *m, const struct spa_dict *sink_props,
		const struct pw_manager_object *card)
{
	struct pw_device_info *card_info = card ? card->info : NULL;
	struct pw_properties *props = NULL;

	if (card_info && card_info->props) {
		props = pw_properties_new_dict(sink_props);
		if (props == NULL)
			return -ENOMEM;

		pw_properties_add(props, card_info->props);
		sink_props = &props->dict;
	}
	message_put(m, TAG_PROPLIST, sink_props, TAG_INVALID);

	pw_properties_free(props);

	return 0;
}

static bool validate_device_info(struct device_info *dev_info)
{
	return sample_spec_valid(&dev_info->ss) &&
	       channel_map_valid(&dev_info->map) &&
	       volume_valid(&dev_info->volume_info.volume);
}

static int fill_sink_info(struct client *client, struct message *m,
		struct pw_manager_object *o)
{
	struct impl *impl = client->impl;
	struct pw_node_info *info = o->info;
	struct pw_manager *manager = client->manager;
	const char *name, *desc, *str;
	char *monitor_name = NULL;
	uint32_t module_id = SPA_ID_INVALID;
	uint32_t card_id = SPA_ID_INVALID;
	struct pw_manager_object *card = NULL;
	uint32_t flags;
	struct card_info card_info = CARD_INFO_INIT;
	struct device_info dev_info = DEVICE_INFO_INIT(PW_DIRECTION_OUTPUT);
	size_t size;

	if (!pw_manager_object_is_sink(o) || info == NULL || info->props == NULL)
		return -ENOENT;

	name = spa_dict_lookup(info->props, PW_KEY_NODE_NAME);
	if ((desc = spa_dict_lookup(info->props, PW_KEY_NODE_DESCRIPTION)) == NULL)
		desc = name ? name : "Unknown";
	if (name == NULL)
		name = "unknown";

	size = strlen(name) + 10;
	monitor_name = alloca(size);
	if (pw_manager_object_is_source(o))
		snprintf(monitor_name, size, "%s", name);
	else
		snprintf(monitor_name, size, "%s.monitor", name);

	if ((str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID)) != NULL)
		module_id = id_to_index(manager, (uint32_t)atoi(str));
	if (module_id == SPA_ID_INVALID &&
	    (str = spa_dict_lookup(info->props, "pulse.module.id")) != NULL)
		module_id = (uint32_t)atoi(str);
	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_ID)) != NULL)
		card_id = (uint32_t)atoi(str);
	if ((str = spa_dict_lookup(info->props, "card.profile.device")) != NULL)
		dev_info.device = (uint32_t)atoi(str);
	if (card_id != SPA_ID_INVALID) {
		struct selector sel = { .id = card_id, .type = pw_manager_object_is_card, };
		card = select_object(manager, &sel);
	}
	if (card)
		collect_card_info(card, &card_info);

	collect_device_info(o, card, &dev_info, false, &impl->defs);

	if (!validate_device_info(&dev_info)) {
		pw_log_warn("%d: sink not ready: sample:%d map:%d volume:%d",
				o->id, sample_spec_valid(&dev_info.ss),
				channel_map_valid(&dev_info.map),
				volume_valid(&dev_info.volume_info.volume));
		return -ENOENT;
	}

	flags = SINK_LATENCY | SINK_DYNAMIC_LATENCY | SINK_DECIBEL_VOLUME;
	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_API)) != NULL)
		flags |= SINK_HARDWARE;
	if ((str = spa_dict_lookup(info->props, PW_KEY_NODE_NETWORK)) != NULL)
		flags |= SINK_NETWORK;
	if (SPA_FLAG_IS_SET(dev_info.volume_info.flags, VOLUME_HW_VOLUME))
		flags |= SINK_HW_VOLUME_CTRL;
	if (SPA_FLAG_IS_SET(dev_info.volume_info.flags, VOLUME_HW_MUTE))
		flags |= SINK_HW_MUTE_CTRL;
	if (dev_info.have_iec958codecs)
		flags |= SINK_SET_FORMATS;

	if (client->quirks & QUIRK_FORCE_S16_FORMAT)
		dev_info.ss.format = SPA_AUDIO_FORMAT_S16;

	message_put(m,
		TAG_U32, o->index,			/* sink index */
		TAG_STRING, name,
		TAG_STRING, desc,
		TAG_SAMPLE_SPEC, &dev_info.ss,
		TAG_CHANNEL_MAP, &dev_info.map,
		TAG_U32, module_id,			/* module index */
		TAG_CVOLUME, &dev_info.volume_info.volume,
		TAG_BOOLEAN, dev_info.volume_info.mute,
		TAG_U32, o->index,			/* monitor source index */
		TAG_STRING, monitor_name,		/* monitor source name */
		TAG_USEC, 0LL,				/* latency */
		TAG_STRING, "PipeWire",			/* driver */
		TAG_U32, flags,				/* flags */
		TAG_INVALID);

	if (client->version >= 13) {
		int res;
		if ((res = fill_sink_info_proplist(m, info->props, card)) < 0)
			return res;
		message_put(m,
			TAG_USEC, 0LL,			/* requested latency */
			TAG_INVALID);
	}
	if (client->version >= 15) {
		bool is_linked = collect_is_linked(manager, o->id, SPA_DIRECTION_INPUT);
		int state = node_state(info->state);

		/* running with nothing linked is probably the monitor that is
		 * keeping this sink busy */
		if (state == STATE_RUNNING && !is_linked)
			state = STATE_IDLE;

		message_put(m,
			TAG_VOLUME, dev_info.volume_info.base,	/* base volume */
			TAG_U32, state,				/* state */
			TAG_U32, dev_info.volume_info.steps,	/* n_volume_steps */
			TAG_U32, card ? card->index : SPA_ID_INVALID,	/* card index */
			TAG_INVALID);
	}
	if (client->version >= 16) {
		uint32_t n_ports, n;
		struct port_info *port_info, *pi;

		port_info = alloca(card_info.n_ports * sizeof(*port_info));
		n_ports = collect_port_info(card, &card_info, &dev_info, port_info);

		message_put(m,
			TAG_U32, n_ports,			/* n_ports */
			TAG_INVALID);
		for (n = 0; n < n_ports; n++) {
			pi = &port_info[n];
			message_put(m,
				TAG_STRING, pi->name,		/* name */
				TAG_STRING, pi->description,	/* description */
				TAG_U32, pi->priority,		/* priority */
				TAG_INVALID);
			if (client->version >= 24) {
				message_put(m,
					TAG_U32, pi->available,		/* available */
					TAG_INVALID);
			}
			if (client->version >= 34) {
				message_put(m,
					TAG_STRING, pi->availability_group,	/* availability_group */
					TAG_U32, pi->type,			/* type */
					TAG_INVALID);
			}
		}
		message_put(m,
			TAG_STRING, dev_info.active_port_name,		/* active port name */
			TAG_INVALID);
	}
	if (client->version >= 21) {
		struct pw_manager_param *p;
		struct format_info info[32];
		uint32_t i, n_info = 0;

		spa_list_for_each(p, &o->param_list, link) {
			uint32_t index = 0;

			if (p->id != SPA_PARAM_EnumFormat)
				continue;

			while (n_info < SPA_N_ELEMENTS(info)) {
				spa_zero(info[n_info]);
				if (format_info_from_param(&info[n_info], p->param, index++) < 0)
					break;
				if (info[n_info].encoding == ENCODING_ANY ||
				    (info[n_info].encoding == ENCODING_PCM && info[n_info].props != NULL)) {
					format_info_clear(&info[n_info]);
					continue;
				}
				n_info++;
			}
		}
		message_put(m,
			TAG_U8, n_info,				/* n_formats */
			TAG_INVALID);
		for (i = 0; i < n_info; i++) {
			message_put(m,
				TAG_FORMAT_INFO, &info[i],
				TAG_INVALID);
			format_info_clear(&info[i]);
		}
	}
	return 0;
}

static int fill_source_info_proplist(struct message *m, const struct spa_dict *source_props,
		const struct pw_manager_object *card, const bool is_monitor)
{
	struct pw_device_info *card_info = card ? card->info : NULL;
	struct pw_properties *props = NULL;

	if ((card_info && card_info->props) || is_monitor) {
		props = pw_properties_new_dict(source_props);
		if (props == NULL)
			return -ENOMEM;

		if (card_info && card_info->props)
			pw_properties_add(props, card_info->props);

		if (is_monitor)
			pw_properties_set(props, PW_KEY_DEVICE_CLASS, "monitor");

		source_props = &props->dict;
	}
	message_put(m, TAG_PROPLIST, source_props, TAG_INVALID);

	pw_properties_free(props);

	return 0;
}

static int fill_source_info(struct client *client, struct message *m,
		struct pw_manager_object *o)
{
	struct impl *impl = client->impl;
	struct pw_node_info *info = o->info;
	struct pw_manager *manager = client->manager;
	bool is_monitor;
	const char *name, *desc, *str;
	char *monitor_name = NULL;
	char *monitor_desc = NULL;
	uint32_t module_id = SPA_ID_INVALID;
	uint32_t card_id = SPA_ID_INVALID;
	struct pw_manager_object *card = NULL;
	uint32_t flags;
	struct card_info card_info = CARD_INFO_INIT;
	struct device_info dev_info = DEVICE_INFO_INIT(PW_DIRECTION_INPUT);
	size_t size;

	is_monitor = pw_manager_object_is_monitor(o);
	if ((!pw_manager_object_is_source(o) && !is_monitor) || info == NULL || info->props == NULL)
		return -ENOENT;

	name = spa_dict_lookup(info->props, PW_KEY_NODE_NAME);
	if ((desc = spa_dict_lookup(info->props, PW_KEY_NODE_DESCRIPTION)) == NULL)
		desc = name ? name : "Unknown";
	if (name == NULL)
		name = "unknown";

	size = strlen(name) + 10;
	monitor_name = alloca(size);
	snprintf(monitor_name, size, "%s.monitor", name);

	size = strlen(desc) + 20;
	monitor_desc = alloca(size);
	snprintf(monitor_desc, size, "Monitor of %s", desc);

	if ((str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID)) != NULL)
		module_id = id_to_index(manager, (uint32_t)atoi(str));
	if (module_id == SPA_ID_INVALID &&
	    (str = spa_dict_lookup(info->props, "pulse.module.id")) != NULL)
		module_id = (uint32_t)atoi(str);
	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_ID)) != NULL)
		card_id = (uint32_t)atoi(str);
	if ((str = spa_dict_lookup(info->props, "card.profile.device")) != NULL)
		dev_info.device = (uint32_t)atoi(str);

	if (card_id != SPA_ID_INVALID) {
		struct selector sel = { .id = card_id, .type = pw_manager_object_is_card, };
		card = select_object(manager, &sel);
	}
	if (card)
		collect_card_info(card, &card_info);

	collect_device_info(o, card, &dev_info, is_monitor, &impl->defs);

	if (!validate_device_info(&dev_info)) {
		pw_log_warn("%d: source not ready: sample:%d map:%d volume:%d",
				o->id, sample_spec_valid(&dev_info.ss),
				channel_map_valid(&dev_info.map),
				volume_valid(&dev_info.volume_info.volume));
		return -ENOENT;
	}

	flags = SOURCE_LATENCY | SOURCE_DYNAMIC_LATENCY | SOURCE_DECIBEL_VOLUME;
	if ((str = spa_dict_lookup(info->props, PW_KEY_DEVICE_API)) != NULL)
		flags |= SOURCE_HARDWARE;
	if ((str = spa_dict_lookup(info->props, PW_KEY_NODE_NETWORK)) != NULL)
		flags |= SOURCE_NETWORK;
	if (SPA_FLAG_IS_SET(dev_info.volume_info.flags, VOLUME_HW_VOLUME))
		flags |= SOURCE_HW_VOLUME_CTRL;
	if (SPA_FLAG_IS_SET(dev_info.volume_info.flags, VOLUME_HW_MUTE))
		flags |= SOURCE_HW_MUTE_CTRL;

	if (client->quirks & QUIRK_FORCE_S16_FORMAT)
		dev_info.ss.format = SPA_AUDIO_FORMAT_S16;

	message_put(m,
		TAG_U32, o->index,				/* source index */
		TAG_STRING, is_monitor ? monitor_name : name,
		TAG_STRING, is_monitor ? monitor_desc : desc,
		TAG_SAMPLE_SPEC, &dev_info.ss,
		TAG_CHANNEL_MAP, &dev_info.map,
		TAG_U32, module_id,				/* module index */
		TAG_CVOLUME, &dev_info.volume_info.volume,
		TAG_BOOLEAN, dev_info.volume_info.mute,
		TAG_U32, is_monitor ? o->index : SPA_ID_INVALID,/* monitor of sink */
		TAG_STRING, is_monitor ? name : NULL,		/* monitor of sink name */
		TAG_USEC, 0LL,					/* latency */
		TAG_STRING, "PipeWire",				/* driver */
		TAG_U32, flags,					/* flags */
		TAG_INVALID);

	if (client->version >= 13) {
		int res;
		if ((res = fill_source_info_proplist(m, info->props, card, is_monitor)) < 0)
			return res;
		message_put(m,
			TAG_USEC, 0LL,			/* requested latency */
			TAG_INVALID);
	}
	if (client->version >= 15) {
		bool is_linked = collect_is_linked(manager, o->id, SPA_DIRECTION_OUTPUT);
		int state = node_state(info->state);

		/* running with nothing linked is probably the sink that is
		 * keeping this source busy */
		if (state == STATE_RUNNING && !is_linked)
			state = STATE_IDLE;

		message_put(m,
			TAG_VOLUME, dev_info.volume_info.base,	/* base volume */
			TAG_U32, state,				/* state */
			TAG_U32, dev_info.volume_info.steps,	/* n_volume_steps */
			TAG_U32, card ? card->index : SPA_ID_INVALID,	/* card index */
			TAG_INVALID);
	}
	if (client->version >= 16) {
		uint32_t n_ports, n;
		struct port_info *port_info, *pi;

		port_info = alloca(card_info.n_ports * sizeof(*port_info));
		n_ports = collect_port_info(card, &card_info, &dev_info, port_info);

		message_put(m,
			TAG_U32, n_ports,			/* n_ports */
			TAG_INVALID);
		for (n = 0; n < n_ports; n++) {
			pi = &port_info[n];
			message_put(m,
				TAG_STRING, pi->name,		/* name */
				TAG_STRING, pi->description,	/* description */
				TAG_U32, pi->priority,		/* priority */
				TAG_INVALID);
			if (client->version >= 24) {
				message_put(m,
					TAG_U32, pi->available,		/* available */
					TAG_INVALID);
			}
			if (client->version >= 34) {
				message_put(m,
					TAG_STRING, pi->availability_group,	/* availability_group */
					TAG_U32, pi->type,			/* type */
					TAG_INVALID);
			}
		}
		message_put(m,
			TAG_STRING, dev_info.active_port_name,		/* active port name */
			TAG_INVALID);
	}
	if (client->version >= 21) {
		struct format_info info;
		spa_zero(info);
		info.encoding = ENCODING_PCM;
		message_put(m,
			TAG_U8, 1,			/* n_formats */
			TAG_FORMAT_INFO, &info,
			TAG_INVALID);
	}
	return 0;
}

static const char *get_media_name(struct pw_node_info *info)
{
	const char *media_name;
	media_name = spa_dict_lookup(info->props, PW_KEY_MEDIA_NAME);
	if (media_name == NULL)
		media_name = "";
	return media_name;
}

static int fill_sink_input_info(struct client *client, struct message *m,
		struct pw_manager_object *o)
{
	struct impl *impl = client->impl;
	struct pw_node_info *info = o->info;
	struct pw_manager *manager = client->manager;
	const char *str;
	uint32_t module_id = SPA_ID_INVALID, client_id = SPA_ID_INVALID;
	uint32_t peer_index;
	struct device_info dev_info = DEVICE_INFO_INIT(PW_DIRECTION_OUTPUT);

	if (!pw_manager_object_is_sink_input(o) || info == NULL || info->props == NULL)
		return -ENOENT;

	if ((str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID)) != NULL)
		module_id = id_to_index(manager, (uint32_t)atoi(str));
	if (module_id == SPA_ID_INVALID &&
	    (str = spa_dict_lookup(info->props, "pulse.module.id")) != NULL)
		module_id = (uint32_t)atoi(str);

	if (!pw_manager_object_is_virtual(o) &&
	    (str = spa_dict_lookup(info->props, PW_KEY_CLIENT_ID)) != NULL)
		client_id = (uint32_t)atoi(str);

	collect_device_info(o, NULL, &dev_info, false, &impl->defs);

	if (!validate_device_info(&dev_info))
		return -ENOENT;

	peer_index = get_temporary_move_target(client, o);
	if (peer_index == SPA_ID_INVALID) {
		struct pw_manager_object *peer;
		peer = find_linked(manager, o->id, PW_DIRECTION_OUTPUT);
		if (peer && pw_manager_object_is_sink(peer))
			peer_index = peer->index;
		else
			peer_index = SPA_ID_INVALID;
	}

	message_put(m,
		TAG_U32, o->index,				/* sink_input index */
		TAG_STRING, get_media_name(info),
		TAG_U32, module_id,				/* module index */
		TAG_U32, id_to_index(manager, client_id),	/* client index */
		TAG_U32, peer_index,				/* sink index */
		TAG_SAMPLE_SPEC, &dev_info.ss,
		TAG_CHANNEL_MAP, &dev_info.map,
		TAG_CVOLUME, &dev_info.volume_info.volume,
		TAG_USEC, 0LL,				/* latency */
		TAG_USEC, 0LL,				/* sink latency */
		TAG_STRING, "PipeWire",			/* resample method */
		TAG_STRING, "PipeWire",			/* driver */
		TAG_INVALID);
	if (client->version >= 11)
		message_put(m,
			TAG_BOOLEAN, dev_info.volume_info.mute,	/* muted */
			TAG_INVALID);
	if (client->version >= 13)
		message_put(m,
			TAG_PROPLIST, info->props,
			TAG_INVALID);
	if (client->version >= 19)
		message_put(m,
			TAG_BOOLEAN, info->state != PW_NODE_STATE_RUNNING,		/* corked */
			TAG_INVALID);
	if (client->version >= 20)
		message_put(m,
			TAG_BOOLEAN, true,		/* has_volume */
			TAG_BOOLEAN, true,		/* volume writable */
			TAG_INVALID);
	if (client->version >= 21) {
		struct format_info fi;
		format_info_from_spec(&fi, &dev_info.ss, &dev_info.map);
		message_put(m,
			TAG_FORMAT_INFO, &fi,
			TAG_INVALID);
		format_info_clear(&fi);
	}
	return 0;
}

static int fill_source_output_info(struct client *client, struct message *m,
		struct pw_manager_object *o)
{
	struct impl *impl = client->impl;
	struct pw_node_info *info = o->info;
	struct pw_manager *manager = client->manager;
	const char *str;
	uint32_t module_id = SPA_ID_INVALID, client_id = SPA_ID_INVALID;
	uint32_t peer_index;
	struct device_info dev_info = DEVICE_INFO_INIT(PW_DIRECTION_INPUT);

	if (!pw_manager_object_is_source_output(o) || info == NULL || info->props == NULL)
		return -ENOENT;

	if ((str = spa_dict_lookup(info->props, PW_KEY_MODULE_ID)) != NULL)
		module_id = id_to_index(manager, (uint32_t)atoi(str));
	if (module_id == SPA_ID_INVALID &&
	    (str = spa_dict_lookup(info->props, "pulse.module.id")) != NULL)
		module_id = (uint32_t)atoi(str);

	if (!pw_manager_object_is_virtual(o) &&
	    (str = spa_dict_lookup(info->props, PW_KEY_CLIENT_ID)) != NULL)
		client_id = (uint32_t)atoi(str);

	collect_device_info(o, NULL, &dev_info, false, &impl->defs);

	if (!validate_device_info(&dev_info))
		return -ENOENT;

	peer_index = get_temporary_move_target(client, o);
	if (peer_index == SPA_ID_INVALID) {
		struct pw_manager_object *peer;
		peer = find_linked(manager, o->id, PW_DIRECTION_INPUT);
		if (peer && pw_manager_object_is_source_or_monitor(peer))
			peer_index = peer->index;
		else
			peer_index = SPA_ID_INVALID;
	}

	message_put(m,
		TAG_U32, o->index,				/* source_output index */
		TAG_STRING, get_media_name(info),
		TAG_U32, module_id,				/* module index */
		TAG_U32, id_to_index(manager, client_id),	/* client index */
		TAG_U32, peer_index,				/* source index */
		TAG_SAMPLE_SPEC, &dev_info.ss,
		TAG_CHANNEL_MAP, &dev_info.map,
		TAG_USEC, 0LL,				/* latency */
		TAG_USEC, 0LL,				/* source latency */
		TAG_STRING, "PipeWire",			/* resample method */
		TAG_STRING, "PipeWire",			/* driver */
		TAG_INVALID);
	if (client->version >= 13)
		message_put(m,
			TAG_PROPLIST, info->props,
			TAG_INVALID);
	if (client->version >= 19)
		message_put(m,
			TAG_BOOLEAN, info->state != PW_NODE_STATE_RUNNING,		/* corked */
			TAG_INVALID);
	if (client->version >= 22) {
		struct format_info fi;
		format_info_from_spec(&fi, &dev_info.ss, &dev_info.map);
		message_put(m,
			TAG_CVOLUME, &dev_info.volume_info.volume,
			TAG_BOOLEAN, dev_info.volume_info.mute,	/* muted */
			TAG_BOOLEAN, true,		/* has_volume */
			TAG_BOOLEAN, true,		/* volume writable */
			TAG_FORMAT_INFO, &fi,
			TAG_INVALID);
		format_info_clear(&fi);
	}
	return 0;
}

static int do_get_info(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct pw_manager *manager = client->manager;
	struct message *reply = NULL;
	int res;
	struct pw_manager_object *o;
	struct selector sel;
	int (*fill_func) (struct client *client, struct message *m, struct pw_manager_object *o) = NULL;

	spa_zero(sel);

	if (message_get(m,
			TAG_U32, &sel.index,
			TAG_INVALID) < 0)
		goto error_protocol;

	reply = reply_new(client, tag);

	if (command == COMMAND_GET_MODULE_INFO && (sel.index & MODULE_FLAG) != 0) {
		struct module *module;
		module = pw_map_lookup(&impl->modules, sel.index & MODULE_INDEX_MASK);
		if (module == NULL)
			goto error_noentity;
		fill_ext_module_info(client, reply, module);
		return client_queue_message(client, reply);
	}

	switch (command) {
	case COMMAND_GET_CLIENT_INFO:
		sel.type = pw_manager_object_is_client;
		fill_func = fill_client_info;
		break;
	case COMMAND_GET_MODULE_INFO:
		sel.type = pw_manager_object_is_module;
		fill_func = fill_module_info;
		break;
	case COMMAND_GET_CARD_INFO:
		sel.type = pw_manager_object_is_card;
		sel.key = PW_KEY_DEVICE_NAME;
		fill_func = fill_card_info;
		break;
	case COMMAND_GET_SINK_INFO:
		sel.type = pw_manager_object_is_sink;
		sel.key = PW_KEY_NODE_NAME;
		fill_func = fill_sink_info;
		break;
	case COMMAND_GET_SOURCE_INFO:
		sel.type = pw_manager_object_is_source_or_monitor;
		sel.key = PW_KEY_NODE_NAME;
		fill_func = fill_source_info;
		break;
	case COMMAND_GET_SINK_INPUT_INFO:
		sel.type = pw_manager_object_is_sink_input;
		fill_func = fill_sink_input_info;
		break;
	case COMMAND_GET_SOURCE_OUTPUT_INFO:
		sel.type = pw_manager_object_is_source_output;
		fill_func = fill_source_output_info;
		break;
	}
	if (sel.key) {
		if (message_get(m,
				TAG_STRING, &sel.value,
				TAG_INVALID) < 0)
			goto error_protocol;
	}
	if (fill_func == NULL)
		goto error_invalid;

	if (sel.index != SPA_ID_INVALID && sel.value != NULL)
		goto error_invalid;

	pw_log_info("[%s] %s tag:%u index:%u name:%s", client->name,
			commands[command].name, tag, sel.index, sel.value);

	if (command == COMMAND_GET_SINK_INFO || command == COMMAND_GET_SOURCE_INFO) {
		o = find_device(client, sel.index, sel.value,
				command == COMMAND_GET_SINK_INFO, NULL);
	} else {
		if (sel.value == NULL && sel.index == SPA_ID_INVALID)
			goto error_invalid;
		o = select_object(manager, &sel);
	}
	if (o == NULL)
		goto error_noentity;

	if ((res = fill_func(client, reply, o)) < 0)
		goto error;

	return client_queue_message(client, reply);

error_protocol:
	res = -EPROTO;
	goto error;
error_noentity:
	res = -ENOENT;
	goto error;
error_invalid:
	res = -EINVAL;
	goto error;
error:
	if (reply)
		message_free(reply, false, false);
	return res;
}

static uint64_t bytes_to_usec(uint64_t length, const struct sample_spec *ss)
{
	uint64_t u;
	uint64_t frame_size = sample_spec_frame_size(ss);
	if (frame_size == 0)
		return 0;
	u = length / frame_size;
	u *= SPA_USEC_PER_SEC;
	u /= ss->rate;
	return u;
}

static int fill_sample_info(struct client *client, struct message *m,
		struct sample *sample)
{
	struct volume vol;

	volume_make(&vol, sample->ss.channels);

	message_put(m,
		TAG_U32, sample->index,
		TAG_STRING, sample->name,
		TAG_CVOLUME, &vol,
		TAG_USEC, bytes_to_usec(sample->length, &sample->ss),
		TAG_SAMPLE_SPEC, &sample->ss,
		TAG_CHANNEL_MAP, &sample->map,
		TAG_U32, sample->length,
		TAG_BOOLEAN, false,			/* lazy */
		TAG_STRING, NULL,			/* filename */
		TAG_INVALID);

	if (client->version >= 13) {
		message_put(m,
			TAG_PROPLIST, &sample->props->dict,
			TAG_INVALID);
	}
	return 0;
}

static int do_get_sample_info(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct message *reply = NULL;
	uint32_t index;
	const char *name;
	struct sample *sample;
	int res;

	if (message_get(m,
			TAG_U32, &index,
			TAG_STRING, &name,
			TAG_INVALID) < 0)
		return -EPROTO;

	if ((index == SPA_ID_INVALID && name == NULL) ||
	    (index != SPA_ID_INVALID && name != NULL))
		return -EINVAL;

	pw_log_info("[%s] %s tag:%u index:%u name:%s", client->name,
			commands[command].name, tag, index, name);

	if ((sample = find_sample(impl, index, name)) == NULL)
		return -ENOENT;

	reply = reply_new(client, tag);
	if ((res = fill_sample_info(client, reply, sample)) < 0)
		goto error;

	return client_queue_message(client, reply);

error:
	if (reply)
		message_free(reply, false, false);
	return res;
}

static int do_get_sample_info_list(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct message *reply;
	union pw_map_item *item;

	pw_log_info("[%s] %s tag:%u", client->name,
			commands[command].name, tag);

	reply = reply_new(client, tag);
	pw_array_for_each(item, &impl->samples.items) {
		struct sample *s = item->data;
		if (pw_map_item_is_free(item))
			continue;
		fill_sample_info(client, reply, s);
	}
	return client_queue_message(client, reply);
}

struct info_list_data {
	struct client *client;
	struct message *reply;
	int (*fill_func) (struct client *client, struct message *m, struct pw_manager_object *o);
};

static int do_list_info(void *data, struct pw_manager_object *object)
{
	struct info_list_data *info = data;
	info->fill_func(info->client, info->reply, object);
	return 0;
}

static int do_info_list_module(void *item, void *data)
{
	struct module *m = item;
	struct info_list_data *info = data;
	fill_ext_module_info(info->client, info->reply, m);
	return 0;
}

static int do_get_info_list(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct pw_manager *manager = client->manager;
	struct info_list_data info;

	pw_log_info("[%s] %s tag:%u", client->name,
			commands[command].name, tag);

	spa_zero(info);
	info.client = client;

	switch (command) {
	case COMMAND_GET_CLIENT_INFO_LIST:
		info.fill_func = fill_client_info;
		break;
	case COMMAND_GET_MODULE_INFO_LIST:
		info.fill_func = fill_module_info;
		break;
	case COMMAND_GET_CARD_INFO_LIST:
		info.fill_func = fill_card_info;
		break;
	case COMMAND_GET_SINK_INFO_LIST:
		info.fill_func = fill_sink_info;
		break;
	case COMMAND_GET_SOURCE_INFO_LIST:
		info.fill_func = fill_source_info;
		break;
	case COMMAND_GET_SINK_INPUT_INFO_LIST:
		info.fill_func = fill_sink_input_info;
		break;
	case COMMAND_GET_SOURCE_OUTPUT_INFO_LIST:
		info.fill_func = fill_source_output_info;
		break;
	default:
		return -ENOTSUP;
	}

	info.reply = reply_new(client, tag);
	if (info.fill_func)
		pw_manager_for_each_object(manager, do_list_info, &info);

	if (command == COMMAND_GET_MODULE_INFO_LIST)
		pw_map_for_each(&impl->modules, do_info_list_module, &info);

	return client_queue_message(client, info.reply);
}

static int do_set_stream_buffer_attr(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel;
	struct stream *stream;
	struct message *reply;
	struct buffer_attr attr;
	bool adjust_latency = false, early_requests = false;

	if (message_get(m,
			TAG_U32, &channel,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u channel:%u", client->name,
			commands[command].name, tag, channel);

	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL)
		return -ENOENT;

	if (command == COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
		if (stream->type != STREAM_TYPE_PLAYBACK)
			return -ENOENT;

		if (message_get(m,
				TAG_U32, &attr.maxlength,
				TAG_U32, &attr.tlength,
				TAG_U32, &attr.prebuf,
				TAG_U32, &attr.minreq,
				TAG_INVALID) < 0)
			return -EPROTO;
	} else {
		if (stream->type != STREAM_TYPE_RECORD)
			return -ENOENT;

		if (message_get(m,
				TAG_U32, &attr.maxlength,
				TAG_U32, &attr.fragsize,
				TAG_INVALID) < 0)
			return -EPROTO;
	}
	if (client->version >= 13) {
		if (message_get(m,
				TAG_BOOLEAN, &adjust_latency,
				TAG_INVALID) < 0)
			return -EPROTO;
	}
	if (client->version >= 14) {
		if (message_get(m,
				TAG_BOOLEAN, &early_requests,
				TAG_INVALID) < 0)
			return -EPROTO;
	}

	reply = reply_new(client, tag);

	stream->adjust_latency = adjust_latency;
	stream->early_requests = early_requests;

	if (command == COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
		stream->lat_usec = set_playback_buffer_attr(stream, &attr);

		message_put(reply,
			TAG_U32, stream->attr.maxlength,
			TAG_U32, stream->attr.tlength,
			TAG_U32, stream->attr.prebuf,
			TAG_U32, stream->attr.minreq,
			TAG_INVALID);
		if (client->version >= 13) {
			message_put(reply,
				TAG_USEC, stream->lat_usec,		/* configured_sink_latency */
				TAG_INVALID);
		}
	} else {
		stream->lat_usec = set_record_buffer_attr(stream, &attr);

		message_put(reply,
			TAG_U32, stream->attr.maxlength,
			TAG_U32, stream->attr.fragsize,
			TAG_INVALID);
		if (client->version >= 13) {
			message_put(reply,
				TAG_USEC, stream->lat_usec,		/* configured_source_latency */
				TAG_INVALID);
		}
	}
	return client_queue_message(client, reply);
}

static int do_update_stream_sample_rate(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t channel, rate;
	struct stream *stream;
	float corr;

	if (message_get(m,
			TAG_U32, &channel,
			TAG_U32, &rate,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u channel:%u rate:%u", client->name,
			commands[command].name, tag, channel, rate);

	stream = pw_map_lookup(&client->streams, channel);
	if (stream == NULL || stream->type == STREAM_TYPE_UPLOAD)
		return -ENOENT;

	stream->rate = rate;

	corr = (double)rate/(double)stream->ss.rate;
	pw_stream_set_control(stream->stream, SPA_PROP_rate, 1, &corr, NULL);

	return reply_simple_ack(client, tag);
}

static int do_extension(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	uint32_t index;
	const char *name;
	const struct extension *ext;

	if (message_get(m,
			TAG_U32, &index,
			TAG_STRING, &name,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u name:%s", client->name,
			commands[command].name, tag, index, name);

	if ((index == SPA_ID_INVALID && name == NULL) ||
	    (index != SPA_ID_INVALID && name != NULL))
		return -EINVAL;

	ext = extension_find(index, name);
	if (ext == NULL)
		return -ENOENT;

	return ext->process(client, tag, m);
}

static int do_set_profile(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	struct pw_manager_object *o;
	const char *profile_name;
	uint32_t profile_index = SPA_ID_INVALID;
	struct selector sel;
	char buf[1024];
	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));

	spa_zero(sel);
	sel.key = PW_KEY_DEVICE_NAME;
	sel.type = pw_manager_object_is_card;

	if (message_get(m,
			TAG_U32, &sel.index,
			TAG_STRING, &sel.value,
			TAG_STRING, &profile_name,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u name:%s profile:%s", client->name,
			commands[command].name, tag, sel.index, sel.value, profile_name);

	if ((sel.index == SPA_ID_INVALID && sel.value == NULL) ||
	    (sel.index != SPA_ID_INVALID && sel.value != NULL))
		return -EINVAL;
	if (profile_name == NULL)
		return -EINVAL;

	if ((o = select_object(manager, &sel)) == NULL)
		return -ENOENT;

	if ((profile_index = find_profile_index(o, profile_name)) == SPA_ID_INVALID)
		return -ENOENT;

	if (!SPA_FLAG_IS_SET(o->permissions, PW_PERM_W | PW_PERM_X))
		return -EACCES;

	if (o->proxy == NULL)
		return -ENOENT;

	pw_device_set_param((struct pw_device*)o->proxy,
			SPA_PARAM_Profile, 0,
			spa_pod_builder_add_object(&b,
				SPA_TYPE_OBJECT_ParamProfile, SPA_PARAM_Profile,
				SPA_PARAM_PROFILE_index, SPA_POD_Int(profile_index),
				SPA_PARAM_PROFILE_save, SPA_POD_Bool(true)));

	return operation_new(client, tag);
}

static int do_set_default(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	struct pw_manager_object *o;
	const char *name, *str;
	int res;
	bool sink = command == COMMAND_SET_DEFAULT_SINK;

	if (message_get(m,
			TAG_STRING, &name,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u name:%s", client->name,
			commands[command].name, tag, name);

	if (name != NULL && (o = find_device(client, SPA_ID_INVALID, name, sink, NULL)) == NULL)
		return -ENOENT;

	if (name != NULL) {
		if (o->props && (str = pw_properties_get(o->props, PW_KEY_NODE_NAME)) != NULL)
			name = str;
		else if (spa_strendswith(name, ".monitor"))
			name = strndupa(name, strlen(name)-8);

		res = pw_manager_set_metadata(manager, client->metadata_default,
				PW_ID_CORE,
				sink ? METADATA_CONFIG_DEFAULT_SINK : METADATA_CONFIG_DEFAULT_SOURCE,
				"Spa:String:JSON", "{ \"name\": \"%s\" }", name);
	} else {
		res = pw_manager_set_metadata(manager, client->metadata_default,
				PW_ID_CORE,
				sink ? METADATA_CONFIG_DEFAULT_SINK : METADATA_CONFIG_DEFAULT_SOURCE,
				NULL, NULL);
	}
	if (res < 0)
		return res;

	/*
	 * The metadata is not necessarily updated within one server sync.
	 * Correct functioning of MOVE_* commands requires knowing the current
	 * default target, so we need to stash temporary values here in case
	 * the client emits them before metadata gets updated.
	 */
	if (sink) {
		free(client->temporary_default_sink);
		client->temporary_default_sink = name ? strdup(name) : NULL;
	} else {
		free(client->temporary_default_source);
		client->temporary_default_source = name ? strdup(name) : NULL;
	}

	return operation_new(client, tag);
}

static int do_suspend(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager_object *o;
	const char *name;
	uint32_t index, cmd;
	bool sink = command == COMMAND_SUSPEND_SINK, suspend;

	if (message_get(m,
			TAG_U32, &index,
			TAG_STRING, &name,
			TAG_BOOLEAN, &suspend,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u name:%s", client->name,
			commands[command].name, tag, index, name);

	if ((o = find_device(client, index, name, sink, NULL)) == NULL)
		return -ENOENT;

	if (o->proxy == NULL)
		return -ENOENT;

	if (suspend) {
		cmd = SPA_NODE_COMMAND_Suspend;
		pw_node_send_command((struct pw_node*)o->proxy, &SPA_NODE_COMMAND_INIT(cmd));
	}
	return operation_new(client, tag);
}

static int do_move_stream(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	struct pw_manager_object *o, *dev, *dev_default;
	uint32_t index, index_device;
	int target_id;
	int64_t target_serial;
	const char *name_device;
	const char *name;
	struct pw_node_info *info;
	struct selector sel;
	int res;
	bool sink = command == COMMAND_MOVE_SINK_INPUT;

	if (message_get(m,
			TAG_U32, &index,
			TAG_U32, &index_device,
			TAG_STRING, &name_device,
			TAG_INVALID) < 0)
		return -EPROTO;

	if ((index_device == SPA_ID_INVALID && name_device == NULL) ||
	    (index_device != SPA_ID_INVALID && name_device != NULL))
		return -EINVAL;

	pw_log_info("[%s] %s tag:%u index:%u device:%d name:%s", client->name,
			commands[command].name, tag, index, index_device, name_device);

	spa_zero(sel);
	sel.index = index;
	sel.type = sink ? pw_manager_object_is_sink_input: pw_manager_object_is_source_output;

	o = select_object(manager, &sel);
	if (o == NULL)
		return -ENOENT;

	info = o->info;
	if (info == NULL || info->props == NULL)
		return -EINVAL;
	if (spa_atob(spa_dict_lookup(info->props, PW_KEY_NODE_DONT_RECONNECT)))
		return -EINVAL;

	if ((dev = find_device(client, index_device, name_device, sink, NULL)) == NULL)
		return -ENOENT;

	/*
	 * The client metadata is not necessarily yet updated after SET_DEFAULT command,
	 * so use the temporary values if they are still set.
	 */
	name = sink ? client->temporary_default_sink : client->temporary_default_source;
	dev_default = find_device(client, SPA_ID_INVALID, name, sink, NULL);

	if (dev == dev_default) {
		/*
		 * When moving streams to a node that is equal to the default,
		 * Pulseaudio understands this to mean '... and unset preferred sink/source',
		 * forgetting target.node. Follow that behavior here.
		 */
		target_id = -1;
		target_serial = -1;
	} else {
		target_id = dev->id;
		target_serial = dev->serial;
	}

	if ((res = pw_manager_set_metadata(manager, client->metadata_default,
			o->id,
			METADATA_TARGET_NODE,
			SPA_TYPE_INFO_BASE"Id", "%d", target_id)) < 0)
		return res;

	if ((res = pw_manager_set_metadata(manager, client->metadata_default,
			o->id,
			METADATA_TARGET_OBJECT,
			SPA_TYPE_INFO_BASE"Id", "%"PRIi64, target_serial)) < 0)
		return res;

	name = spa_dict_lookup(info->props, PW_KEY_NODE_NAME);
	pw_log_debug("[%s] %s done tag:%u index:%u name:%s target:%d target-serial:%"PRIi64, client->name,
			commands[command].name, tag, index, name ? name : "<null>",
			target_id, target_serial);

	/* We will temporarily claim the stream was already moved */
	set_temporary_move_target(client, o, dev->index);
	send_object_event(client, o, SUBSCRIPTION_EVENT_CHANGE);

	return reply_simple_ack(client, tag);
}

static int do_kill(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct pw_manager *manager = client->manager;
	struct pw_manager_object *o;
	uint32_t index;
	struct selector sel;

	if (message_get(m,
			TAG_U32, &index,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u", client->name,
			commands[command].name, tag, index);

	spa_zero(sel);
	sel.index = index;
	switch (command) {
	case COMMAND_KILL_CLIENT:
		sel.type = pw_manager_object_is_client;
		break;
	case COMMAND_KILL_SINK_INPUT:
		sel.type = pw_manager_object_is_sink_input;
		break;
	case COMMAND_KILL_SOURCE_OUTPUT:
		sel.type = pw_manager_object_is_source_output;
		break;
	default:
		return -EINVAL;
	}

	if ((o = select_object(manager, &sel)) == NULL)
		return -ENOENT;

	pw_registry_destroy(manager->registry, o->id);

	return reply_simple_ack(client, tag);
}

static void handle_module_loaded(struct module *module, struct client *client, uint32_t tag, int result)
{
	const char *client_name = client != NULL ? client->name : "?";
	struct impl *impl = module->impl;

	spa_assert(!SPA_RESULT_IS_ASYNC(result));

	if (SPA_RESULT_IS_OK(result)) {
		pw_log_info("[%s] loaded module index:%u name:%s tag:%d",
				client_name, module->index, module->info->name, tag);

		module->loaded = true;

		broadcast_subscribe_event(impl,
			SUBSCRIPTION_MASK_MODULE,
			SUBSCRIPTION_EVENT_NEW | SUBSCRIPTION_EVENT_MODULE,
			module->index);

		if (client != NULL) {
			struct message *reply = reply_new(client, tag);

			message_put(reply,
				TAG_U32, module->index,
				TAG_INVALID);
			client_queue_message(client, reply);
		}
	}
	else {
		pw_log_warn("%p: [%s] failed to load module index:%u name:%s tag:%d result:%d (%s)",
				impl, client_name,
				module->index, module->info->name, tag,
				result, spa_strerror(result));

		module_schedule_unload(module);

		if (client != NULL)
			reply_error(client, COMMAND_LOAD_MODULE, tag, result);
	}
}

struct pending_module {
	struct client *client;
	struct spa_hook client_listener;

	struct module *module;
	struct spa_hook module_listener;

	struct spa_hook manager_listener;

	uint32_t tag;

	int result;
	bool wait_sync;
};

static void finish_pending_module(struct pending_module *pm)
{
	spa_hook_remove(&pm->module_listener);

	if (pm->client != NULL) {
		spa_hook_remove(&pm->client_listener);
		spa_hook_remove(&pm->manager_listener);
	}

	handle_module_loaded(pm->module, pm->client, pm->tag, pm->result);
	free(pm);
}

static void on_load_module_manager_sync(void *data)
{
	struct pending_module *pm = data;

	pw_log_debug("pending module %p: manager sync wait_sync:%d tag:%d",
			pm, pm->wait_sync, pm->tag);

	if (!pm->wait_sync)
		return;

	finish_pending_module(pm);
}

static void on_module_loaded(void *data, int result)
{
	struct pending_module *pm = data;

	pw_log_debug("pending module %p: loaded, result:%d tag:%d",
			pm, result, pm->tag);

	pm->result = result;

	/*
	 * Do manager sync first: the module may have its own core, so
	 * although things are completed on the server, our client
	 * might not yet see them.
	 */

	if (pm->client == NULL) {
		finish_pending_module(pm);
	} else {
		pw_log_debug("pending module %p: wait manager sync tag:%d", pm, pm->tag);
		pm->wait_sync = true;
		pw_manager_sync(pm->client->manager);
	}
}

static void on_module_destroy(void *data)
{
	struct pending_module *pm = data;

	pw_log_debug("pending module %p: destroyed, tag:%d",
			pm, pm->tag);

	pm->result = -ECANCELED;
	finish_pending_module(pm);
}

static void on_client_disconnect(void *data)
{
	struct pending_module *pm = data;

	pw_log_debug("pending module %p: client disconnect tag:%d", pm, pm->tag);

	spa_hook_remove(&pm->client_listener);
	spa_hook_remove(&pm->manager_listener);
	pm->client = NULL;

	if (pm->wait_sync)
		finish_pending_module(pm);
}

static void on_load_module_manager_disconnect(void *data)
{
	on_client_disconnect(data);
}

static int do_load_module(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	static const struct module_events module_events = {
		VERSION_MODULE_EVENTS,
		.loaded = on_module_loaded,
		.destroy = on_module_destroy,
	};
	static const struct client_events client_events = {
		VERSION_CLIENT_EVENTS,
		.disconnect = on_client_disconnect,
	};
	static const struct pw_manager_events manager_events = {
		PW_VERSION_MANAGER_EVENTS,
		.disconnect = on_load_module_manager_disconnect,
		.sync = on_load_module_manager_sync,
	};

	struct impl *impl = client->impl;
	const char *name, *argument;
	struct module *module;
	struct pending_module *pm;
	int r;

	if (message_get(m,
			TAG_STRING, &name,
			TAG_STRING, &argument,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s name:%s argument:%s",
			client->name, commands[command].name, name, argument);

	module = module_create(impl, name, argument);
	if (module == NULL)
		return -errno;

	pm = calloc(1, sizeof(*pm));
	if (pm == NULL)
		return -errno;

	pm->tag = tag;
	pm->client = client;
	pm->module = module;

	pw_log_debug("pending module %p: start tag:%d", pm, tag);

	r = module_load(module);

	module_add_listener(module, &pm->module_listener, &module_events, pm);
	client_add_listener(client, &pm->client_listener, &client_events, pm);
	pw_manager_add_listener(client->manager, &pm->manager_listener, &manager_events, pm);

	if (!SPA_RESULT_IS_ASYNC(r))
		on_module_loaded(pm, r);

	/*
	 * return 0 to prevent `handle_packet()` from sending a reply
	 * because we want `handle_module_loaded()` to send the reply
	 */
	return 0;
}

static int do_unload_module(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct module *module;
	uint32_t module_index;

	if (message_get(m,
			TAG_U32, &module_index,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u index:%u", client->name,
			commands[command].name, tag, module_index);

	if (module_index == SPA_ID_INVALID)
		return -EINVAL;
	if ((module_index & MODULE_FLAG) == 0)
		return -EPERM;

	module = pw_map_lookup(&impl->modules, module_index & MODULE_INDEX_MASK);
	if (module == NULL)
		return -ENOENT;

	module_unload(module);

	return operation_new(client, tag);
}

static int do_send_object_message(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	struct impl *impl = client->impl;
	struct pw_manager *manager = client->manager;
	const char *object_path = NULL;
	const char *message = NULL;
	const char *params = NULL;
	char *response = NULL;
	char *path = NULL;
	struct message *reply;
	struct pw_manager_object *o;
	int len = 0;
	int res;

	if (message_get(m,
			TAG_STRING, &object_path,
			TAG_STRING, &message,
			TAG_STRING, &params,
			TAG_INVALID) < 0)
		return -EPROTO;

	pw_log_info("[%s] %s tag:%u object_path:'%s' message:'%s' params:'%s'",
			client->name, commands[command].name, tag, object_path,
			message, params ? params : "<null>");

	if (object_path == NULL || message == NULL)
		return -EINVAL;

	len = strlen(object_path);
	if (len > 0 && object_path[len - 1] == '/')
		--len;
	path = strndup(object_path, len);
	if (path == NULL)
		return -ENOMEM;

	res = -ENOENT;

	spa_list_for_each(o, &manager->object_list, link) {
		if (o->message_object_path && spa_streq(o->message_object_path, path)) {
			if (o->message_handler)
				res = o->message_handler(manager, o, message, params, &response);
			else
				res = -ENOSYS;
			break;
		}
	}

	free(path);
	if (res < 0)
		return res;

	pw_log_debug("%p: object message response:'%s'", impl, response ? response : "<null>");

	reply = reply_new(client, tag);
	message_put(reply, TAG_STRING, response, TAG_INVALID);
	free(response);
	return client_queue_message(client, reply);
}

static int do_error_access(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	return -EACCES;
}

static SPA_UNUSED int do_error_not_implemented(struct client *client, uint32_t command, uint32_t tag, struct message *m)
{
	return -ENOSYS;
}

#define COMMAND(name, ...) [COMMAND_ ## name] = { #name, __VA_ARGS__ }
const struct command commands[COMMAND_MAX] =
{
	COMMAND(ERROR),
	COMMAND(TIMEOUT), /* pseudo command */
	COMMAND(REPLY),

	/* CLIENT->SERVER */
	COMMAND(CREATE_PLAYBACK_STREAM, do_create_playback_stream),
	COMMAND(DELETE_PLAYBACK_STREAM, do_delete_stream),
	COMMAND(CREATE_RECORD_STREAM, do_create_record_stream),
	COMMAND(DELETE_RECORD_STREAM, do_delete_stream),
	COMMAND(EXIT, do_error_access),
	COMMAND(AUTH, do_command_auth, COMMAND_ACCESS_WITHOUT_AUTH | COMMAND_ACCESS_WITHOUT_MANAGER),
	COMMAND(SET_CLIENT_NAME, do_set_client_name, COMMAND_ACCESS_WITHOUT_MANAGER),
	COMMAND(LOOKUP_SINK, do_lookup),
	COMMAND(LOOKUP_SOURCE, do_lookup),
	COMMAND(DRAIN_PLAYBACK_STREAM, do_drain_stream),
	COMMAND(STAT, do_stat, COMMAND_ACCESS_WITHOUT_MANAGER),
	COMMAND(GET_PLAYBACK_LATENCY, do_get_playback_latency),
	COMMAND(CREATE_UPLOAD_STREAM, do_create_upload_stream),
	COMMAND(DELETE_UPLOAD_STREAM, do_delete_stream),
	COMMAND(FINISH_UPLOAD_STREAM, do_finish_upload_stream),
	COMMAND(PLAY_SAMPLE, do_play_sample),
	COMMAND(REMOVE_SAMPLE, do_remove_sample),

	COMMAND(GET_SERVER_INFO, do_get_server_info, COMMAND_ACCESS_WITHOUT_MANAGER),
	COMMAND(GET_SINK_INFO, do_get_info),
	COMMAND(GET_SOURCE_INFO, do_get_info),
	COMMAND(GET_MODULE_INFO, do_get_info),
	COMMAND(GET_CLIENT_INFO, do_get_info),
	COMMAND(GET_SINK_INPUT_INFO, do_get_info),
	COMMAND(GET_SOURCE_OUTPUT_INFO, do_get_info),
	COMMAND(GET_SAMPLE_INFO, do_get_sample_info),
	COMMAND(GET_CARD_INFO, do_get_info),
	COMMAND(SUBSCRIBE, do_subscribe),

	COMMAND(GET_SINK_INFO_LIST, do_get_info_list),
	COMMAND(GET_SOURCE_INFO_LIST, do_get_info_list),
	COMMAND(GET_MODULE_INFO_LIST, do_get_info_list),
	COMMAND(GET_CLIENT_INFO_LIST, do_get_info_list),
	COMMAND(GET_SINK_INPUT_INFO_LIST, do_get_info_list),
	COMMAND(GET_SOURCE_OUTPUT_INFO_LIST, do_get_info_list),
	COMMAND(GET_SAMPLE_INFO_LIST, do_get_sample_info_list),
	COMMAND(GET_CARD_INFO_LIST, do_get_info_list),

	COMMAND(SET_SINK_VOLUME, do_set_volume),
	COMMAND(SET_SINK_INPUT_VOLUME, do_set_stream_volume),
	COMMAND(SET_SOURCE_VOLUME, do_set_volume),

	COMMAND(SET_SINK_MUTE, do_set_mute),
	COMMAND(SET_SOURCE_MUTE, do_set_mute),

	COMMAND(CORK_PLAYBACK_STREAM, do_cork_stream),
	COMMAND(FLUSH_PLAYBACK_STREAM, do_flush_trigger_prebuf_stream),
	COMMAND(TRIGGER_PLAYBACK_STREAM, do_flush_trigger_prebuf_stream),
	COMMAND(PREBUF_PLAYBACK_STREAM, do_flush_trigger_prebuf_stream),

	COMMAND(SET_DEFAULT_SINK, do_set_default),
	COMMAND(SET_DEFAULT_SOURCE, do_set_default),

	COMMAND(SET_PLAYBACK_STREAM_NAME, do_set_stream_name),
	COMMAND(SET_RECORD_STREAM_NAME, do_set_stream_name),

	COMMAND(KILL_CLIENT, do_kill),
	COMMAND(KILL_SINK_INPUT, do_kill),
	COMMAND(KILL_SOURCE_OUTPUT, do_kill),

	COMMAND(LOAD_MODULE, do_load_module),
	COMMAND(UNLOAD_MODULE, do_unload_module),

	/* Obsolete */
	COMMAND(ADD_AUTOLOAD___OBSOLETE, do_error_access),
	COMMAND(REMOVE_AUTOLOAD___OBSOLETE, do_error_access),
	COMMAND(GET_AUTOLOAD_INFO___OBSOLETE, do_error_access),
	COMMAND(GET_AUTOLOAD_INFO_LIST___OBSOLETE, do_error_access),

	COMMAND(GET_RECORD_LATENCY, do_get_record_latency),
	COMMAND(CORK_RECORD_STREAM, do_cork_stream),
	COMMAND(FLUSH_RECORD_STREAM, do_flush_trigger_prebuf_stream),

	/* SERVER->CLIENT */
	COMMAND(REQUEST),
	COMMAND(OVERFLOW),
	COMMAND(UNDERFLOW),
	COMMAND(PLAYBACK_STREAM_KILLED),
	COMMAND(RECORD_STREAM_KILLED),
	COMMAND(SUBSCRIBE_EVENT),

	/* A few more client->server commands */

	/* Supported since protocol v10 (0.9.5) */
	COMMAND(MOVE_SINK_INPUT, do_move_stream),
	COMMAND(MOVE_SOURCE_OUTPUT, do_move_stream),

	/* Supported since protocol v11 (0.9.7) */
	COMMAND(SET_SINK_INPUT_MUTE, do_set_stream_mute),

	COMMAND(SUSPEND_SINK, do_suspend),
	COMMAND(SUSPEND_SOURCE, do_suspend),

	/* Supported since protocol v12 (0.9.8) */
	COMMAND(SET_PLAYBACK_STREAM_BUFFER_ATTR, do_set_stream_buffer_attr),
	COMMAND(SET_RECORD_STREAM_BUFFER_ATTR, do_set_stream_buffer_attr),

	COMMAND(UPDATE_PLAYBACK_STREAM_SAMPLE_RATE, do_update_stream_sample_rate),
	COMMAND(UPDATE_RECORD_STREAM_SAMPLE_RATE, do_update_stream_sample_rate),

	/* SERVER->CLIENT */
	COMMAND(PLAYBACK_STREAM_SUSPENDED),
	COMMAND(RECORD_STREAM_SUSPENDED),
	COMMAND(PLAYBACK_STREAM_MOVED),
	COMMAND(RECORD_STREAM_MOVED),

	/* Supported since protocol v13 (0.9.11) */
	COMMAND(UPDATE_RECORD_STREAM_PROPLIST, do_update_proplist),
	COMMAND(UPDATE_PLAYBACK_STREAM_PROPLIST, do_update_proplist),
	COMMAND(UPDATE_CLIENT_PROPLIST, do_update_proplist),

	COMMAND(REMOVE_RECORD_STREAM_PROPLIST, do_remove_proplist),
	COMMAND(REMOVE_PLAYBACK_STREAM_PROPLIST, do_remove_proplist),
	COMMAND(REMOVE_CLIENT_PROPLIST, do_remove_proplist),

	/* SERVER->CLIENT */
	COMMAND(STARTED),

	/* Supported since protocol v14 (0.9.12) */
	COMMAND(EXTENSION, do_extension),
	/* Supported since protocol v15 (0.9.15) */
	COMMAND(SET_CARD_PROFILE, do_set_profile),

	/* SERVER->CLIENT */
	COMMAND(CLIENT_EVENT),
	COMMAND(PLAYBACK_STREAM_EVENT),
	COMMAND(RECORD_STREAM_EVENT),

	/* SERVER->CLIENT */
	COMMAND(PLAYBACK_BUFFER_ATTR_CHANGED),
	COMMAND(RECORD_BUFFER_ATTR_CHANGED),

	/* Supported since protocol v16 (0.9.16) */
	COMMAND(SET_SINK_PORT, do_set_port),
	COMMAND(SET_SOURCE_PORT, do_set_port),

	/* Supported since protocol v22 (1.0) */
	COMMAND(SET_SOURCE_OUTPUT_VOLUME,  do_set_stream_volume),
	COMMAND(SET_SOURCE_OUTPUT_MUTE,  do_set_stream_mute),

	/* Supported since protocol v27 (3.0) */
	COMMAND(SET_PORT_LATENCY_OFFSET, do_set_port_latency_offset),

	/* Supported since protocol v30 (6.0) */
	/* BOTH DIRECTIONS */
	COMMAND(ENABLE_SRBCHANNEL, do_error_access),
	COMMAND(DISABLE_SRBCHANNEL, do_error_access),

	/* Supported since protocol v31 (9.0)
	 * BOTH DIRECTIONS */
	COMMAND(REGISTER_MEMFD_SHMID, do_error_access),

	/* Supported since protocol v35 (15.0) */
	COMMAND(SEND_OBJECT_MESSAGE, do_send_object_message),
};
#undef COMMAND

static int impl_free_sample(void *item, void *data)
{
	struct sample *s = item;

	spa_assert(s->ref == 1);
	sample_unref(s);

	return 0;
}

static int impl_unload_module(void *item, void *data)
{
	struct module *m = item;
	module_unload(m);
	return 0;
}

static void impl_clear(struct impl *impl)
{
	struct message *msg;
	struct server *s;
	struct client *c;

	pw_map_for_each(&impl->modules, impl_unload_module, impl);
	pw_map_clear(&impl->modules);

	spa_list_consume(s, &impl->servers, link)
		server_free(s);

	spa_list_consume(c, &impl->cleanup_clients, link)
		client_free(c);

	spa_list_consume(msg, &impl->free_messages, link)
		message_free(msg, true, true);

	pw_map_for_each(&impl->samples, impl_free_sample, impl);
	pw_map_clear(&impl->samples);

	spa_hook_list_clean(&impl->hooks);

#ifdef HAVE_DBUS
	if (impl->dbus_name) {
		dbus_release_name(impl->dbus_name);
		impl->dbus_name = NULL;
	}
#endif

	if (impl->context) {
		spa_hook_remove(&impl->context_listener);
		impl->context = NULL;
	}

	pw_properties_free(impl->props);
	impl->props = NULL;
}

static void impl_free(struct impl *impl)
{
	impl_clear(impl);
	free(impl);
}

static void context_destroy(void *data)
{
	impl_clear(data);
}

static const struct pw_context_events context_events = {
	PW_VERSION_CONTEXT_EVENTS,
	.destroy = context_destroy,
};

static int parse_frac(struct pw_properties *props, const char *key, const char *def,
		struct spa_fraction *res)
{
	const char *str;
	if (props == NULL ||
	    (str = pw_properties_get(props, key)) == NULL)
		str = def;
	if (sscanf(str, "%u/%u", &res->num, &res->denom) != 2 || res->denom == 0) {
		pw_log_warn(": invalid fraction %s, default to %s", str, def);
		sscanf(def, "%u/%u", &res->num, &res->denom);
	}
	pw_log_info(": defaults: %s = %u/%u", key, res->num, res->denom);
	return 0;
}

static int parse_position(struct pw_properties *props, const char *key, const char *def,
		struct channel_map *res)
{
	const char *str;
	struct spa_json it[2];
	char v[256];

	if (props == NULL ||
	    (str = pw_properties_get(props, key)) == NULL)
		str = def;

	spa_json_init(&it[0], str, strlen(str));
	if (spa_json_enter_array(&it[0], &it[1]) <= 0)
		spa_json_init(&it[1], str, strlen(str));

	res->channels = 0;
	while (spa_json_get_string(&it[1], v, sizeof(v)) > 0 &&
	    res->channels < SPA_AUDIO_MAX_CHANNELS) {
		res->map[res->channels++] = channel_name2id(v);
	}
	pw_log_info(": defaults: %s = %s", key, str);
	return 0;
}
static int parse_format(struct pw_properties *props, const char *key, const char *def,
		struct sample_spec *res)
{
	const char *str;
	if (props == NULL ||
	    (str = pw_properties_get(props, key)) == NULL)
		str = def;
	res->format = format_name2id(str);
	if (res->format == SPA_AUDIO_FORMAT_UNKNOWN) {
		pw_log_warn(": unknown format %s, default to %s", str, def);
		res->format = format_name2id(def);
	}
	pw_log_info(": defaults: %s = %s", key, format_id2name(res->format));
	return 0;
}
static int parse_uint32(struct pw_properties *props, const char *key, const char *def,
		uint32_t *res)
{
	const char *str;
	if (props == NULL ||
	    (str = pw_properties_get(props, key)) == NULL)
		str = def;
	if (!spa_atou32(str, res, 0)) {
		pw_log_warn(": invalid uint32_t %s, default to %s", str, def);
		spa_atou32(def, res, 0);
	}
	pw_log_info(": defaults: %s = %u", key, *res);
	return 0;
}

static void load_defaults(struct defs *def, struct pw_properties *props)
{
	parse_frac(props, "pulse.min.req", DEFAULT_MIN_REQ, &def->min_req);
	parse_frac(props, "pulse.default.req", DEFAULT_DEFAULT_REQ, &def->default_req);
	parse_frac(props, "pulse.min.frag", DEFAULT_MIN_FRAG, &def->min_frag);
	parse_frac(props, "pulse.default.frag", DEFAULT_DEFAULT_FRAG, &def->default_frag);
	parse_frac(props, "pulse.default.tlength", DEFAULT_DEFAULT_TLENGTH, &def->default_tlength);
	parse_frac(props, "pulse.min.quantum", DEFAULT_MIN_QUANTUM, &def->min_quantum);
	parse_format(props, "pulse.default.format", DEFAULT_FORMAT, &def->sample_spec);
	parse_position(props, "pulse.default.position", DEFAULT_POSITION, &def->channel_map);
	parse_uint32(props, "pulse.idle.timeout", DEFAULT_IDLE_TIMEOUT, &def->idle_timeout);
	def->sample_spec.channels = def->channel_map.channels;
	def->quantum_limit = 8192;
}

struct pw_protocol_pulse *pw_protocol_pulse_new(struct pw_context *context,
		struct pw_properties *props, size_t user_data_size)
{
	const struct spa_support *support;
	struct spa_cpu *cpu;
	uint32_t n_support;
	struct impl *impl;
	const char *str;
	int res = 0;

	impl = calloc(1, sizeof(*impl) + user_data_size);
	if (impl == NULL)
		goto error_exit;

	if (props == NULL)
		props = pw_properties_new(NULL, NULL);
	if (props == NULL)
		goto error_free;

	support = pw_context_get_support(context, &n_support);
	cpu = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_CPU);

	pw_context_conf_update_props(context, "pulse.properties", props);

	if ((str = pw_properties_get(props, "vm.overrides")) != NULL) {
		if (cpu != NULL && spa_cpu_get_vm_type(cpu) != SPA_CPU_VM_NONE)
			pw_properties_update_string(props, str, strlen(str));
		pw_properties_set(props, "vm.overrides", NULL);
	}

	load_defaults(&impl->defs, props);

	debug_messages = pw_log_topic_enabled(SPA_LOG_LEVEL_INFO, pulse_conn);

	impl->context = context;
	impl->loop = pw_context_get_main_loop(context);
	impl->props = props;

	impl->work_queue = pw_context_get_work_queue(context);

	spa_hook_list_init(&impl->hooks);
	spa_list_init(&impl->servers);
	impl->rate_limit.interval = 2 * SPA_NSEC_PER_SEC;
	impl->rate_limit.burst = 1;
	pw_map_init(&impl->samples, 16, 16);
	pw_map_init(&impl->modules, 16, 16);
	spa_list_init(&impl->cleanup_clients);
	spa_list_init(&impl->free_messages);

	str = pw_properties_get(props, "server.address");
	if (str == NULL) {
		pw_properties_setf(props, "server.address",
				"[ \"%s-%s\" ]",
				PW_PROTOCOL_PULSE_DEFAULT_SERVER,
				get_server_name(context));
		str = pw_properties_get(props, "server.address");
	}

	if (str == NULL)
		goto error_free;

	if ((res = servers_create_and_start(impl, str, NULL)) < 0) {
		pw_log_error("%p: no servers could be started: %s",
				impl, spa_strerror(res));
		goto error_free;
	}

	if ((res = create_pid_file()) < 0) {
		pw_log_warn("%p: can't create pid file: %s",
				impl, spa_strerror(res));
	}
	pw_context_add_listener(context, &impl->context_listener,
			&context_events, impl);

#ifdef HAVE_DBUS
	impl->dbus_name = dbus_request_name(context, "org.pulseaudio.Server");
#endif
	cmd_run(impl);

	return (struct pw_protocol_pulse *) impl;

error_free:
	free(impl);

error_exit:
	pw_properties_free(props);

	if (res < 0)
		errno = -res;

	return NULL;
}

void impl_add_listener(struct impl *impl,
		struct spa_hook *listener,
		const struct impl_events *events, void *data)
{
	spa_hook_list_append(&impl->hooks, listener, events, data);
}

void *pw_protocol_pulse_get_user_data(struct pw_protocol_pulse *pulse)
{
	return SPA_PTROFF(pulse, sizeof(struct impl), void);
}

void pw_protocol_pulse_destroy(struct pw_protocol_pulse *pulse)
{
	struct impl *impl = (struct impl*)pulse;
	impl_free(impl);
}
