/*

 *  PCM - Direct Stream Mixing

 *  Copyright (c) 2003 by Jaroslav Kysela <perex@perex.cz>

 *

 *

 *   This library is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as

 *   published by the Free Software Foundation; either version 2.1 of

 *   the License, or (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public

 *   License along with this library; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <stddef.h>

#include <unistd.h>

#include <signal.h>

#include <string.h>

#include <fcntl.h>

#include <ctype.h>

#include <grp.h>

#include <sys/ioctl.h>

#include <sys/mman.h>

#include <poll.h>

#include <sys/shm.h>

#include <sys/sem.h>

#include <sys/wait.h>

#include <sys/socket.h>

#include <sys/stat.h>

#include <sys/un.h>

#include <sys/mman.h>

#include "pcm_direct.h"

/*

 *

 */

union semun {

	int              val;    /* Value for SETVAL */

	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */

	unsigned short  *array;  /* Array for GETALL, SETALL */

	struct seminfo  *__buf;  /* Buffer for IPC_INFO (Linux specific) */

};

/*

 * FIXME:

 *  add possibility to use futexes here

 */

int snd_pcm_direct_semaphore_create_or_connect(snd_pcm_direct_t *dmix)

{

	union semun s;

	struct semid_ds buf;

	int i;

	dmix->semid = semget(dmix->ipc_key, DIRECT_IPC_SEMS,

			     IPC_CREAT | dmix->ipc_perm);

	if (dmix->semid < 0)

		return -errno;

	if (dmix->ipc_gid < 0)

		return 0;

	for (i = 0; i < DIRECT_IPC_SEMS; i++) {

		s.buf = &buf;

		if (semctl(dmix->semid, i, IPC_STAT, s) < 0) {

			int err = -errno;

			snd_pcm_direct_semaphore_discard(dmix);

			return err;

		}

		buf.sem_perm.gid = dmix->ipc_gid;

		s.buf = &buf;

		semctl(dmix->semid, i, IPC_SET, s);

	}

	return 0;

}

#define SND_PCM_DIRECT_MAGIC	(0xa15ad300 + sizeof(snd_pcm_direct_share_t))

/*

 *  global shared memory area 

 */

int snd_pcm_direct_shm_create_or_connect(snd_pcm_direct_t *dmix)

{

	struct shmid_ds buf;

	int tmpid, err, first_instance = 0;

retryget:

	dmix->shmid = shmget(dmix->ipc_key, sizeof(snd_pcm_direct_share_t),

			     dmix->ipc_perm);

	if (dmix->shmid < 0 && errno == ENOENT) {

		if ((dmix->shmid = shmget(dmix->ipc_key, sizeof(snd_pcm_direct_share_t),

					     IPC_CREAT | IPC_EXCL | dmix->ipc_perm)) != -1)

			first_instance = 1;

		else if (errno == EEXIST)

			goto retryget;

	}

	err = -errno;

	if (dmix->shmid < 0) {

		if (errno == EINVAL)

		if ((tmpid = shmget(dmix->ipc_key, 0, dmix->ipc_perm)) != -1)

		if (!shmctl(tmpid, IPC_STAT, &buf))

		if (!buf.shm_nattch)

	    	/* no users so destroy the segment */

		if (!shmctl(tmpid, IPC_RMID, NULL))

		    goto retryget;

		return err;

	}

	dmix->shmptr = shmat(dmix->shmid, 0, 0);

	if (dmix->shmptr == (void *) -1) {

		err = -errno;

		snd_pcm_direct_shm_discard(dmix);

		return err;

	}

	mlock(dmix->shmptr, sizeof(snd_pcm_direct_share_t));

	if (shmctl(dmix->shmid, IPC_STAT, &buf) < 0) {

		err = -errno;

		snd_pcm_direct_shm_discard(dmix);

		return err;

	}

	if (first_instance) {	/* we're the first user, clear the segment */

		memset(dmix->shmptr, 0, sizeof(snd_pcm_direct_share_t));

		if (dmix->ipc_gid >= 0) {

			buf.shm_perm.gid = dmix->ipc_gid;

			shmctl(dmix->shmid, IPC_SET, &buf;;

		}

		dmix->shmptr->magic = SND_PCM_DIRECT_MAGIC;

		return 1;

	} else {

		if (dmix->shmptr->magic != SND_PCM_DIRECT_MAGIC) {

			snd_pcm_direct_shm_discard(dmix);

			return -EINVAL;

		}

	}

	return 0;

}

/* discard shared memory */

/*

 * Define snd_* functions to be used in server.

 * Since objects referred in a plugin can be released dynamically, a forked

 * server should have statically linked functions.

 * (e.g. Novell bugzilla #105772)

 */

static int _snd_pcm_direct_shm_discard(snd_pcm_direct_t *dmix)

{

	struct shmid_ds buf;

	int ret = 0;

	if (dmix->shmid < 0)

		return -EINVAL;

	if (dmix->shmptr != (void *) -1 && shmdt(dmix->shmptr) < 0)

		return -errno;

	dmix->shmptr = (void *) -1;

	if (shmctl(dmix->shmid, IPC_STAT, &buf) < 0)

		return -errno;

	if (buf.shm_nattch == 0) {	/* we're the last user, destroy the segment */

		if (shmctl(dmix->shmid, IPC_RMID, NULL) < 0)

			return -errno;

		ret = 1;

	}

	dmix->shmid = -1;

	return ret;

}

/* ... and an exported version */

int snd_pcm_direct_shm_discard(snd_pcm_direct_t *dmix)

{

	return _snd_pcm_direct_shm_discard(dmix);

}

/*

 *  server side

 */

static int get_tmp_name(char *filename, size_t size)

{

	struct timeval tv;

	gettimeofday(&tv, NULL);

	snprintf(filename, size, TMPDIR "/alsa-dmix-%i-%li-%li", (int)getpid(), (long)tv.tv_sec, (long)tv.tv_usec);

	filename[size-1] = '\0';

	return 0;

}

static int make_local_socket(const char *filename, int server, mode_t ipc_perm, int ipc_gid)

{

	size_t l = strlen(filename);

	size_t size = offsetof(struct sockaddr_un, sun_path) + l;

	struct sockaddr_un *addr = alloca(size);

	int sock;

	sock = socket(PF_LOCAL, SOCK_STREAM, 0);

	if (sock < 0) {

		int result = -errno;

		SYSERR("socket failed");

		return result;

	}

	if (server)

		unlink(filename);

	memset(addr, 0, size); /* make valgrind happy */

	addr->sun_family = AF_LOCAL;

	memcpy(addr->sun_path, filename, l);

	if (server) {

		if (bind(sock, (struct sockaddr *) addr, size) < 0) {

			int result = -errno;

			SYSERR("bind failed: %s", filename);

			close(sock);

			return result;

		} else {

			if (chmod(filename, ipc_perm) < 0) {

				int result = -errno;

				SYSERR("chmod failed: %s", filename);

				close(sock);

				unlink(filename);

				return result;

			}

			if (chown(filename, -1, ipc_gid) < 0) {

#if 0 /* it's not fatal */

				int result = -errno;

				SYSERR("chown failed: %s", filename);

				close(sock);

				unlink(filename);

				return result;

#endif

			}

		}

	} else {

		if (connect(sock, (struct sockaddr *) addr, size) < 0) {

			int result = -errno;

			SYSERR("connect failed: %s", filename);

			close(sock);

			return result;

		}

	}

	return sock;

}

#if 0

#define SERVER_JOB_DEBUG

#define server_printf(fmt, args...) printf(fmt, ##args)

#else

#undef SERVER_JOB_DEBUG

#define server_printf(fmt, args...) /* nothing */

#endif

static snd_pcm_direct_t *server_job_dmix;

static void server_cleanup(snd_pcm_direct_t *dmix)

{

	close(dmix->server_fd);

	close(dmix->hw_fd);

	if (dmix->server_free)

		dmix->server_free(dmix);

	unlink(dmix->shmptr->socket_name);

	_snd_pcm_direct_shm_discard(dmix);

	snd_pcm_direct_semaphore_discard(dmix);

}

static void server_job_signal(int sig ATTRIBUTE_UNUSED)

{

	snd_pcm_direct_semaphore_down(server_job_dmix, DIRECT_IPC_SEM_CLIENT);

	server_cleanup(server_job_dmix);

	server_printf("DIRECT SERVER EXIT - SIGNAL\n");

	_exit(EXIT_SUCCESS);

}

/* This is a copy from ../socket.c, provided here only for a server job

 * (see the comment above)

 */

static int _snd_send_fd(int sock, void *data, size_t len, int fd)

{

	int ret;

	size_t cmsg_len = CMSG_LEN(sizeof(int));

	struct cmsghdr *cmsg = alloca(cmsg_len);

	int *fds = (int *) CMSG_DATA(cmsg);

	struct msghdr msghdr;

	struct iovec vec;

	vec.iov_base = (void *)&dat;;

	vec.iov_len = len;

	cmsg->cmsg_len = cmsg_len;

	cmsg->cmsg_level = SOL_SOCKET;

	cmsg->cmsg_type = SCM_RIGHTS;

	*fds = fd;

	msghdr.msg_name = NULL;

	msghdr.msg_namelen = 0;

	msghdr.msg_iov = &vec;

 	msghdr.msg_iovlen = 1;

	msghdr.msg_control = cmsg;

	msghdr.msg_controllen = cmsg_len;

	msghdr.msg_flags = 0;

	ret = sendmsg(sock, &msghdr, 0 );

	if (ret < 0)

		return -errno;

	return ret;

}

static void server_job(snd_pcm_direct_t *dmix)

{

	int ret, sck, i;

	int max = 128, current = 0;

	struct pollfd pfds[max + 1];

	server_job_dmix = dmix;

	/* don't allow to be killed */

	signal(SIGHUP, server_job_signal);

	signal(SIGQUIT, server_job_signal);

	signal(SIGTERM, server_job_signal);

	signal(SIGKILL, server_job_signal);

	/* close all files to free resources */

	i = sysconf(_SC_OPEN_MAX);

#ifdef SERVER_JOB_DEBUG

	while (--i >= 3) {

#else

	while (--i >= 0) {

#endif

		if (i != dmix->server_fd && i != dmix->hw_fd)

			close(i);

	}

	/* detach from parent */

	setsid();

	pfds[0].fd = dmix->server_fd;

	pfds[0].events = POLLIN | POLLERR | POLLHUP;

	server_printf("DIRECT SERVER STARTED\n");

	while (1) {

		ret = poll(pfds, current + 1, 500);

		server_printf("DIRECT SERVER: poll ret = %i, revents[0] = 0x%x, errno = %i\n", ret, pfds[0].revents, errno);

		if (ret < 0) {

			if (errno == EINTR)

				continue;

			/* some error */

			break;

		}

		if (ret == 0 || (pfds[0].revents & (POLLERR | POLLHUP))) {	/* timeout or error? */

			struct shmid_ds buf;

			snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT);

			if (shmctl(dmix->shmid, IPC_STAT, &buf) < 0) {

				_snd_pcm_direct_shm_discard(dmix);

				snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);

				continue;

			}

			server_printf("DIRECT SERVER: nattch = %i\n", (int)buf.shm_nattch);

			if (buf.shm_nattch == 1)	/* server is the last user, exit */

				break;

			snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);

			continue;

		}

		if (pfds[0].revents & POLLIN) {

			ret--;

			sck = accept(dmix->server_fd, 0, 0);

			if (sck >= 0) {

				server_printf("DIRECT SERVER: new connection %i\n", sck);

				if (current == max) {

					close(sck);

				} else {

					unsigned char buf = 'A';

					pfds[current+1].fd = sck;

					pfds[current+1].events = POLLIN | POLLERR | POLLHUP;

					_snd_send_fd(sck, &buf, 1, dmix->hw_fd);

					server_printf("DIRECT SERVER: fd sent ok\n");

					current++;

				}

			}

		}

		for (i = 0; i < current && ret > 0; i++) {

			struct pollfd *pfd = &pfds[i+1];

			unsigned char cmd;

			server_printf("client %i revents = 0x%x\n", pfd->fd, pfd->revents);

			if (pfd->revents & (POLLERR | POLLHUP)) {

				ret--;

				close(pfd->fd);

				pfd->fd = -1;

				continue;

			}

			if (!(pfd->revents & POLLIN))

				continue;

			ret--;

			if (read(pfd->fd, &cmd, 1) == 1)

				cmd = 0 /*process command */;

		}

		for (i = 0; i < current; i++) {

			if (pfds[i+1].fd < 0) {

				if (i + 1 != max)

					memcpy(&pfds[i+1], &pfds[i+2], sizeof(struct pollfd) * (max - i - 1));

				current--;

			}

		}

	}

	server_cleanup(dmix);

	server_printf("DIRECT SERVER EXIT\n");

#ifdef SERVER_JOB_DEBUG

	close(0); close(1); close(2);

#endif

	_exit(EXIT_SUCCESS);

}

int snd_pcm_direct_server_create(snd_pcm_direct_t *dmix)

{

	int ret;

	dmix->server_fd = -1;

	ret = get_tmp_name(dmix->shmptr->socket_name, sizeof(dmix->shmptr->socket_name));

	if (ret < 0)

		return ret;

	ret = make_local_socket(dmix->shmptr->socket_name, 1, dmix->ipc_perm, dmix->ipc_gid);

	if (ret < 0)

		return ret;

	dmix->server_fd = ret;

	ret = listen(dmix->server_fd, 4);

	if (ret < 0) {

		close(dmix->server_fd);

		return ret;

	}

	ret = fork();

	if (ret < 0) {

		close(dmix->server_fd);

		return ret;

	} else if (ret == 0) {

		ret = fork();

		if (ret == 0)

			server_job(dmix);

		_exit(EXIT_SUCCESS);

	} else {

		waitpid(ret, NULL, 0);

	}

	dmix->server_pid = ret;

	dmix->server = 1;

	return 0;

}

int snd_pcm_direct_server_discard(snd_pcm_direct_t *dmix)

{

	if (dmix->server) {

		//kill(dmix->server_pid, SIGTERM);

		//waitpid(dmix->server_pid, NULL, 0);

		dmix->server_pid = (pid_t)-1;

	}

	if (dmix->server_fd > 0) {

		close(dmix->server_fd);

		dmix->server_fd = -1;

	}

	dmix->server = 0;

	return 0;

}

/*

 *  client side

 */

int snd_pcm_direct_client_connect(snd_pcm_direct_t *dmix)

{

	int ret;

	unsigned char buf;

	ret = make_local_socket(dmix->shmptr->socket_name, 0, -1, -1);

	if (ret < 0)

		return ret;

	dmix->comm_fd = ret;

	ret = snd_receive_fd(dmix->comm_fd, &buf, 1, &dmix->hw_fd);

	if (ret < 1 || buf != 'A') {

		close(dmix->comm_fd);

		dmix->comm_fd = -1;

		return ret;

	}

	dmix->client = 1;

	return 0;

}

int snd_pcm_direct_client_discard(snd_pcm_direct_t *dmix)

{

	if (dmix->client) {

		close(dmix->comm_fd);

		dmix->comm_fd = -1;

	}

	return 0;

}

/*

 *  plugin helpers

 */

int snd_pcm_direct_nonblock(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int nonblock ATTRIBUTE_UNUSED)

{

	/* value is cached for us in pcm->mode (SND_PCM_NONBLOCK flag) */

	return 0;

}

int snd_pcm_direct_async(snd_pcm_t *pcm, int sig, pid_t pid)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	return snd_timer_async(dmix->timer, sig, pid);

}

/* empty the timer read queue */

int snd_pcm_direct_clear_timer_queue(snd_pcm_direct_t *dmix)

{

	int changed = 0;

	if (dmix->timer_need_poll) {

		while (poll(&dmix->timer_fd, 1, 0) > 0) {

			changed++;

			/* we don't need the value */

			if (dmix->tread) {

				snd_timer_tread_t rbuf[4];

				snd_timer_read(dmix->timer, rbuf, sizeof(rbuf));

			} else {

				snd_timer_read_t rbuf;

				snd_timer_read(dmix->timer, &rbuf, sizeof(rbuf));

			}

		}

	} else {

		if (dmix->tread) {

			snd_timer_tread_t rbuf[4];

			int len;

			while ((len = snd_timer_read(dmix->timer, rbuf,

						     sizeof(rbuf))) > 0

						     && (++changed) &&

			       len != sizeof(rbuf[0]))

				;

		} else {

			snd_timer_read_t rbuf;

			while (snd_timer_read(dmix->timer, &rbuf, sizeof(rbuf)) > 0)

				changed++;

		}

	}

	return changed;

}

int snd_pcm_direct_timer_stop(snd_pcm_direct_t *dmix)

{

	snd_timer_stop(dmix->timer);

	return 0;

}

/*

 * Recover slave on XRUN.

 * Even if direct plugins disable xrun detection, there might be an xrun

 * raised directly by some drivers.

 * The first client recovers slave pcm.

 * Each client needs to execute sw xrun handling afterwards

 */

int snd_pcm_direct_slave_recover(snd_pcm_direct_t *direct)

{

	int ret;

	int semerr;

	semerr = snd_pcm_direct_semaphore_down(direct,

						   DIRECT_IPC_SEM_CLIENT);

	if (semerr < 0) {

		SNDERR("SEMDOWN FAILED with err %d", semerr);

		return semerr;

	}

	if (snd_pcm_state(direct->spcm) != SND_PCM_STATE_XRUN) {

		/* ignore... someone else already did recovery */

		semerr = snd_pcm_direct_semaphore_up(direct,

						     DIRECT_IPC_SEM_CLIENT);

		if (semerr < 0) {

			SNDERR("SEMUP FAILED with err %d", semerr);

			return semerr;

		}

		return 0;

	}

	ret = snd_pcm_prepare(direct->spcm);

	if (ret < 0) {

		SNDERR("recover: unable to prepare slave");

		semerr = snd_pcm_direct_semaphore_up(direct,

						     DIRECT_IPC_SEM_CLIENT);

		if (semerr < 0) {

			SNDERR("SEMUP FAILED with err %d", semerr);

			return semerr;

		}

		return ret;

	}

	if (direct->type == SND_PCM_TYPE_DSHARE) {

		const snd_pcm_channel_area_t *dst_areas;

		dst_areas = snd_pcm_mmap_areas(direct->spcm);

		snd_pcm_areas_silence(dst_areas, 0, direct->spcm->channels,

				      direct->spcm->buffer_size,

				      direct->spcm->format);

	}

	ret = snd_pcm_start(direct->spcm);

	if (ret < 0) {

		SNDERR("recover: unable to start slave");

		semerr = snd_pcm_direct_semaphore_up(direct,

						     DIRECT_IPC_SEM_CLIENT);

		if (semerr < 0) {

			SNDERR("SEMUP FAILED with err %d", semerr);

			return semerr;

		}

		return ret;

	}

	direct->shmptr->s.recoveries++;

	semerr = snd_pcm_direct_semaphore_up(direct,

						 DIRECT_IPC_SEM_CLIENT);

	if (semerr < 0) {

		SNDERR("SEMUP FAILED with err %d", semerr);

		return semerr;

	}

	return 0;

}

/*

 * enter xrun state, if slave xrun occurred

 * @return: 0 - no xrun >0: xrun happened

 */

int snd_pcm_direct_client_chk_xrun(snd_pcm_direct_t *direct, snd_pcm_t *pcm)

{

	if (direct->shmptr->s.recoveries != direct->recoveries) {

		/* no matter how many xruns we missed -

		 * so don't increment but just update to actual counter

		 */

		direct->recoveries = direct->shmptr->s.recoveries;

		pcm->fast_ops->drop(pcm);

		/* trigger_tstamp update is missing in drop callbacks */

		gettimestamp(&direct->trigger_tstamp, pcm->tstamp_type);

		/* no timer clear:

		 * if slave already entered xrun again the event is lost.

		 * snd_pcm_direct_clear_timer_queue(direct);

		 */

		direct->state = SND_PCM_STATE_XRUN;

		return 1;

	}

	return 0;

}

/*

 * This is the only operation guaranteed to be called before entering poll().

 * Direct plugins use fd of snd_timer to poll on, these timers do NOT check

 * state of substream in kernel by intention.

 * Only the enter to xrun might be notified once (SND_TIMER_EVENT_MSTOP).

 * If xrun event was not correctly handled or was ignored it will never be

 * evaluated again afterwards.

 * This will result in snd_pcm_wait() always returning timeout.

 * In contrast poll() on pcm hardware checks ALSA state and will immediately

 * return POLLERR on XRUN.

 *

 * To prevent timeout and applications endlessly spinning without xrun

 * detected we add a state check here which may trigger the xrun sequence.

 *

 * return count of filled descriptors or negative error code

 */

int snd_pcm_direct_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds,

				    unsigned int space)

{

	if (pcm->poll_fd < 0) {

		SNDMSG("poll_fd < 0");

		return -EIO;

	}

	if (space >= 1 && pfds) {

		pfds->fd = pcm->poll_fd;

		pfds->events = pcm->poll_events | POLLERR | POLLNVAL;

	} else {

		return 0;

	}

	/* this will also evaluate slave state and enter xrun if necessary */

	/* using __snd_pcm_state() since this function is called inside lock */

	switch (__snd_pcm_state(pcm)) {

	case SND_PCM_STATE_XRUN:

		return -EPIPE;

	default:

		break;

	}

	return 1;

}

int snd_pcm_direct_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	unsigned short events;

	int empty = 0;

	assert(pfds && nfds == 1 && revents);

timer_changed:

	events = pfds[0].revents;

	if (events & POLLIN) {

		snd_pcm_uframes_t avail;

		__snd_pcm_avail_update(pcm);

		if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {

			events |= POLLOUT;

			events &= ~POLLIN;

			avail = snd_pcm_mmap_playback_avail(pcm);

		} else {

			avail = snd_pcm_mmap_capture_avail(pcm);

		}

		empty = avail < pcm->avail_min;

	}

	switch (snd_pcm_state(dmix->spcm)) {

	case SND_PCM_STATE_XRUN:

		/* recover slave and update client state to xrun

		 * before returning POLLERR

		 */

		snd_pcm_direct_slave_recover(dmix);

		snd_pcm_direct_client_chk_xrun(dmix, pcm);

		/* fallthrough */

	case SND_PCM_STATE_SUSPENDED:

	case SND_PCM_STATE_SETUP:

		events |= POLLERR;

		break;

	default:

		if (empty) {

			/* here we have a race condition:

			 * if period event arrived after the avail_update call

			 * above we might clear this event with the following

			 * clear_timer_queue.

			 * There is no way to do this in atomic manner, so we

			 * need to recheck avail_update if we successfully

			 * cleared a poll event.

			 */

			if (snd_pcm_direct_clear_timer_queue(dmix))

				goto timer_changed;

			events &= ~(POLLOUT|POLLIN);

			/* additional check */

			switch (__snd_pcm_state(pcm)) {

			case SND_PCM_STATE_XRUN:

			case SND_PCM_STATE_SUSPENDED:

			case SND_PCM_STATE_SETUP:

				events |= POLLERR;

				break;

			default:

				break;

			}

		}

		break;

	}

	*revents = events;

	return 0;

}

int snd_pcm_direct_info(snd_pcm_t *pcm, snd_pcm_info_t * info)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	if (dmix->spcm && !dmix->shmptr->use_server)

		return snd_pcm_info(dmix->spcm, info);

	memset(info, 0, sizeof(*info));

	info->stream = pcm->stream;

	info->card = -1;

	/* FIXME: fill this with something more useful: we know the hardware name */

	if (pcm->name) {

		snd_strlcpy((char *)info->id, pcm->name, sizeof(info->id));

		snd_strlcpy((char *)info->name, pcm->name, sizeof(info->name));

		snd_strlcpy((char *)info->subname, pcm->name, sizeof(info->subname));

	}

	info->subdevices_count = 1;

	return 0;

}

static inline snd_mask_t *hw_param_mask(snd_pcm_hw_params_t *params,

					snd_pcm_hw_param_t var)

{

	return &params->masks[var - SND_PCM_HW_PARAM_FIRST_MASK];

}

static inline snd_interval_t *hw_param_interval(snd_pcm_hw_params_t *params,

						snd_pcm_hw_param_t var)

{

	return &params->intervals[var - SND_PCM_HW_PARAM_FIRST_INTERVAL];

}

static int hw_param_interval_refine_one(snd_pcm_hw_params_t *params,

					snd_pcm_hw_param_t var,

					snd_interval_t *src)

{

	snd_interval_t *i;

	if (!(params->rmask & (1<

		return 0;

	i = hw_param_interval(params, var);

	if (snd_interval_empty(i)) {

		SNDERR("dshare interval %i empty?", (int)var);

		return -EINVAL;

	}

	if (snd_interval_refine(i, src))

		params->cmask |= 1<

	return 0;

}

static int hw_param_interval_refine_minmax(snd_pcm_hw_params_t *params,

					   snd_pcm_hw_param_t var,

					   unsigned int imin,

					   unsigned int imax)

{

	snd_interval_t t;

	memset(&t, 0, sizeof(t));

	snd_interval_set_minmax(&t, imin, imax);

	t.integer = 1;

	return hw_param_interval_refine_one(params, var, &t);

}

/* this code is used 'as-is' from the alsa kernel code */

static int snd_interval_step(struct snd_interval *i, unsigned int min,

			     unsigned int step)

{

	unsigned int n;

	int changed = 0;

	n = (i->min - min) % step;

	if (n != 0 || i->openmin) {

		i->min += step - n;

		changed = 1;

	}

	n = (i->max - min) % step;

	if (n != 0 || i->openmax) {

		i->max -= n;

		changed = 1;

	}

	if (snd_interval_checkempty(i)) {

		i->empty = 1;

		return -EINVAL;

	}

	return changed;

}

#undef REFINE_DEBUG

int snd_pcm_direct_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

{

	snd_pcm_direct_t *dshare = pcm->private_data;

	static const snd_mask_t access = { .bits = { 

					(1<

					(1<

					(1<

					(1<

					0, 0, 0 } };

	int err;

#ifdef REFINE_DEBUG

	snd_output_t *log;

	snd_output_stdio_attach(&log, stderr, 0);

	snd_output_puts(log, "DMIX REFINE (begin):\n");

	snd_pcm_hw_params_dump(params, log);

#endif

	if (params->rmask & (1<

		if (snd_mask_empty(hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS))) {

			SNDERR("dshare access mask empty?");

			return -EINVAL;

		}

		if (snd_mask_refine(hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS), &access))

			params->cmask |= 1<

	}

	if (params->rmask & (1<

		if (snd_mask_empty(hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT))) {

			SNDERR("dshare format mask empty?");

			return -EINVAL;

		}

		if (snd_mask_refine_set(hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT),

					dshare->shmptr->hw.format))

			params->cmask |= 1<

	}

	//snd_mask_none(hw_param_mask(params, SND_PCM_HW_PARAM_SUBFORMAT));

	if (params->rmask & (1<