/**

 * \file pcm/pcm_share.c

 * \ingroup PCM_Plugins

 * \brief PCM Share Plugin Interface

 * \author Abramo Bagnara <abramo@alsa-project.org>

 * \date 2000-2001

 */

/*

 *  PCM - Share

 *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>

 *

 *

 *   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 <limits.h>

#include <unistd.h>

#include <string.h>

#include <signal.h>

#include <math.h>

#include <sys/socket.h>

#include <poll.h>

#include <pthread.h>

#include "pcm_local.h"

#ifndef PIC

/* entry for static linking */

const char *_snd_module_pcm_share = "";

#endif

#ifndef DOC_HIDDEN

static LIST_HEAD(snd_pcm_share_slaves);

static pthread_mutex_t snd_pcm_share_slaves_mutex = PTHREAD_MUTEX_INITIALIZER;

#ifdef MUTEX_DEBUG

#define Pthread_mutex_lock(mutex) \

char *snd_pcm_share_slaves_mutex_holder;

do { \

	int err = pthread_mutex_trylock(mutex); \

	if (err < 0) { \

		fprintf(stderr, "lock " #mutex " is busy (%s): waiting in " __func__ "\n", *(mutex##_holder)); \

		pthread_mutex_lock(mutex); \

		fprintf(stderr, "... got\n"); \

	} \

	*(mutex##_holder) = __func__; \

} while (0)

#define Pthread_mutex_unlock(mutex) \

do { \

	*(mutex##_holder) = 0; \

	pthread_mutex_unlock(mutex); \

} while (0)

#else

#define Pthread_mutex_lock(mutex) pthread_mutex_lock(mutex)

#define Pthread_mutex_unlock(mutex) pthread_mutex_unlock(mutex)

#endif

typedef struct {

	struct list_head clients;

	struct list_head list;

	snd_pcm_t *pcm;

	snd_pcm_format_t format;

	int rate;

	unsigned int channels;

	snd_pcm_sframes_t period_time;

	snd_pcm_sframes_t buffer_time;

	unsigned int open_count;

	unsigned int setup_count;

	unsigned int prepared_count;

	unsigned int running_count;

	snd_pcm_uframes_t safety_threshold;

	snd_pcm_uframes_t silence_frames;

	snd_pcm_sw_params_t sw_params;

	snd_pcm_uframes_t hw_ptr;

	int poll[2];

	int polling;

	pthread_t thread;

	pthread_mutex_t mutex;

#ifdef MUTEX_DEBUG

	char *mutex_holder;

#endif

	pthread_cond_t poll_cond;

} snd_pcm_share_slave_t;

typedef struct {

	struct list_head list;

	snd_pcm_t *pcm;

	snd_pcm_share_slave_t *slave;

	unsigned int channels;

	unsigned int *slave_channels;

	int drain_silenced;

	snd_htimestamp_t trigger_tstamp;

	snd_pcm_state_t state;

	snd_pcm_uframes_t hw_ptr;

	snd_pcm_uframes_t appl_ptr;

	int ready;

	int client_socket;

	int slave_socket;

} snd_pcm_share_t;

#endif /* DOC_HIDDEN */

static void _snd_pcm_share_stop(snd_pcm_t *pcm, snd_pcm_state_t state);

static snd_pcm_uframes_t snd_pcm_share_slave_avail(snd_pcm_share_slave_t *slave)

{

	snd_pcm_sframes_t avail;

	snd_pcm_t *pcm = slave->pcm;

  	avail = slave->hw_ptr - *pcm->appl.ptr;

	if (pcm->stream == SND_PCM_STREAM_PLAYBACK)

		avail += pcm->buffer_size;

	if (avail < 0)

		avail += pcm->boundary;

	else if ((snd_pcm_uframes_t) avail >= pcm->boundary)

		avail -= pcm->boundary;

	return avail;

}

/* Warning: take the mutex before to call this */

/* Return number of frames to mmap_commit the slave */

static snd_pcm_uframes_t _snd_pcm_share_slave_forward(snd_pcm_share_slave_t *slave)

{

	struct list_head *i;

	snd_pcm_uframes_t buffer_size;

	snd_pcm_sframes_t frames, safety_frames;

	snd_pcm_sframes_t min_frames, max_frames;

	snd_pcm_uframes_t avail, slave_avail;

	snd_pcm_uframes_t slave_hw_avail;

	slave_avail = snd_pcm_share_slave_avail(slave);

	buffer_size = slave->pcm->buffer_size;

	min_frames = slave_avail;

	max_frames = 0;

	list_for_each(i, &slave->clients) {

		snd_pcm_share_t *share = list_entry(i, snd_pcm_share_t, list);

		snd_pcm_t *pcm = share->pcm;

		switch (share->state) {

		case SND_PCM_STATE_RUNNING:

			break;

		case SND_PCM_STATE_DRAINING:

			if (pcm->stream != SND_PCM_STREAM_PLAYBACK)

				continue;

			break;

		default:

			continue;

		}

		avail = snd_pcm_mmap_avail(pcm);

		frames = slave_avail - avail;

		if (frames > max_frames)

			max_frames = frames;

		if (share->state != SND_PCM_STATE_RUNNING)

			continue;

		if (frames < min_frames)

			min_frames = frames;

	}

	if (max_frames == 0)

		return 0;

	frames = min_frames;

	/* Slave xrun prevention */

	slave_hw_avail = buffer_size - slave_avail;

	safety_frames = slave->safety_threshold - slave_hw_avail;

	if (safety_frames > 0 &&

	    frames < safety_frames) {

		/* Avoid to pass over the last */

		if (max_frames < safety_frames)

			frames = max_frames;

		else

			frames = safety_frames;

	}

	if (frames < 0)

		return 0;

	return frames;

}

/* 

   - stop PCM on xrun

   - update poll status

   - draining silencing

   - return distance in frames to next event

*/

static snd_pcm_uframes_t _snd_pcm_share_missing(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_t *spcm = slave->pcm;

	snd_pcm_uframes_t buffer_size = spcm->buffer_size;

	int ready = 1, running = 0;

	snd_pcm_uframes_t avail = 0, slave_avail;

	snd_pcm_sframes_t hw_avail;

	snd_pcm_uframes_t missing = INT_MAX;

	snd_pcm_sframes_t ready_missing;

	// printf("state=%s hw_ptr=%ld appl_ptr=%ld slave appl_ptr=%ld safety=%ld silence=%ld\n", snd_pcm_state_name(share->state), slave->hw_ptr, share->appl_ptr, *slave->pcm->appl_ptr, slave->safety_threshold, slave->silence_frames);

	switch (share->state) {

	case SND_PCM_STATE_RUNNING:

		break;

	case SND_PCM_STATE_DRAINING:

		if (pcm->stream == SND_PCM_STREAM_PLAYBACK)

			break;

		/* Fall through */

	default:

		return INT_MAX;

	}

	share->hw_ptr = slave->hw_ptr;

	avail = snd_pcm_mmap_avail(pcm);

	if (avail >= pcm->stop_threshold) {

		_snd_pcm_share_stop(pcm, share->state == SND_PCM_STATE_DRAINING ? SND_PCM_STATE_SETUP : SND_PCM_STATE_XRUN);

		goto update_poll;

	}

	hw_avail = buffer_size - avail;

	slave_avail = snd_pcm_share_slave_avail(slave);

	if (avail < slave_avail) {

		/* Some frames need still to be transferred */

		snd_pcm_sframes_t slave_hw_avail = buffer_size - slave_avail;

		snd_pcm_sframes_t safety_missing = slave_hw_avail - slave->safety_threshold;

		if (safety_missing < 0) {

			snd_pcm_sframes_t err;

			snd_pcm_sframes_t frames = slave_avail - avail;

			if (-safety_missing <= frames) {

				frames = -safety_missing;

				missing = 1;

			}

			err = snd_pcm_mmap_commit(spcm, snd_pcm_mmap_offset(spcm), frames);

			if (err < 0) {

				SYSMSG("snd_pcm_mmap_commit error");

				return INT_MAX;

			}

			if (err != frames)

				SYSMSG("commit returns %ld for size %ld", err, frames);

			slave_avail -= err;

		} else {

			if (safety_missing == 0)

				missing = 1;

			else

				missing = safety_missing;

		}

	}

	switch (share->state) {

	case SND_PCM_STATE_DRAINING:

		if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {

			if (hw_avail <= 0) {

				_snd_pcm_share_stop(pcm, SND_PCM_STATE_SETUP);

				break;

			}

			if ((snd_pcm_uframes_t)hw_avail < missing)

				missing = hw_avail;

			running = 1;

			ready = 0;

		}

		break;

	case SND_PCM_STATE_RUNNING:

		if (avail >= pcm->stop_threshold) {

			_snd_pcm_share_stop(pcm, SND_PCM_STATE_XRUN);

			break;

		} else {

			snd_pcm_uframes_t xrun_missing = pcm->stop_threshold - avail;

			if (missing > xrun_missing)

				missing = xrun_missing;

		}

		ready_missing = pcm->avail_min - avail;

		if (ready_missing > 0) {

			ready = 0;

			if (missing > (snd_pcm_uframes_t)ready_missing)

				missing = ready_missing;

		}

		running = 1;

		break;

	default:

		SNDERR("invalid shared PCM state %d", share->state);

		return INT_MAX;

	}

 update_poll:

	if (ready != share->ready) {

		char buf[1];

		if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {

			if (ready)

				read(share->slave_socket, buf, 1);

			else

				write(share->client_socket, buf, 1);

		} else {

			if (ready)

				write(share->slave_socket, buf, 1);

			else

				read(share->client_socket, buf, 1);

		}

		share->ready = ready;

	}

	if (!running)

		return INT_MAX;

	if (pcm->stream == SND_PCM_STREAM_PLAYBACK &&

	    share->state == SND_PCM_STATE_DRAINING &&

	    !share->drain_silenced) {

		/* drain silencing */

		if (avail >= slave->silence_frames) {

			snd_pcm_uframes_t offset = share->appl_ptr % buffer_size;

			snd_pcm_uframes_t xfer = 0;

			snd_pcm_uframes_t size = slave->silence_frames;

			while (xfer < size) {

				snd_pcm_uframes_t frames = size - xfer;

				snd_pcm_uframes_t cont = buffer_size - offset;

				if (cont < frames)

					frames = cont;

				snd_pcm_areas_silence(pcm->running_areas, offset, pcm->channels, frames, pcm->format);

				offset += frames;

				if (offset >= buffer_size)

					offset = 0;

				xfer += frames;

			}

			share->drain_silenced = 1;

		} else {

			snd_pcm_uframes_t silence_missing;

			silence_missing = slave->silence_frames - avail;

			if (silence_missing < missing)

				missing = silence_missing;

		}

	}

	// printf("missing=%d\n", missing);

	return missing;

}

static snd_pcm_uframes_t _snd_pcm_share_slave_missing(snd_pcm_share_slave_t *slave)

{

	snd_pcm_uframes_t missing = INT_MAX;

	struct list_head *i;

	/* snd_pcm_sframes_t avail = */ snd_pcm_avail_update(slave->pcm);

	slave->hw_ptr = *slave->pcm->hw.ptr;

	list_for_each(i, &slave->clients) {

		snd_pcm_share_t *share = list_entry(i, snd_pcm_share_t, list);

		snd_pcm_t *pcm = share->pcm;

		snd_pcm_uframes_t m = _snd_pcm_share_missing(pcm);

		if (m < missing)

			missing = m;

	}

	return missing;

}

static void *snd_pcm_share_thread(void *data)

{

	snd_pcm_share_slave_t *slave = data;

	snd_pcm_t *spcm = slave->pcm;

	struct pollfd pfd[2];

	int err;

	pfd[0].fd = slave->poll[0];

	pfd[0].events = POLLIN;

	err = snd_pcm_poll_descriptors(spcm, &pfd[1], 1);

	if (err != 1) {

		SNDERR("invalid poll descriptors %d", err);

		return NULL;

	}

	Pthread_mutex_lock(&slave->mutex);

	err = pipe(slave->poll);

	if (err < 0) {

		SYSERR("can't create a pipe");

		Pthread_mutex_unlock(&slave->mutex);

		return NULL;

	}

	while (slave->open_count > 0) {

		snd_pcm_uframes_t missing;

		// printf("begin min_missing\n");

		missing = _snd_pcm_share_slave_missing(slave);

		// printf("min_missing=%ld\n", missing);

		if (missing < INT_MAX) {

			snd_pcm_uframes_t hw_ptr;

			snd_pcm_sframes_t avail_min;

			hw_ptr = slave->hw_ptr + missing;

			hw_ptr += spcm->period_size - 1;

			if (hw_ptr >= spcm->boundary)

				hw_ptr -= spcm->boundary;

			hw_ptr -= hw_ptr % spcm->period_size;

			avail_min = hw_ptr - *spcm->appl.ptr;

			if (spcm->stream == SND_PCM_STREAM_PLAYBACK)

				avail_min += spcm->buffer_size;

			if (avail_min < 0)

				avail_min += spcm->boundary;

			// printf("avail_min=%d\n", avail_min);

			if ((snd_pcm_uframes_t)avail_min != spcm->avail_min) {

				snd_pcm_sw_params_set_avail_min(spcm, &slave->sw_params, avail_min);

				err = snd_pcm_sw_params(spcm, &slave->sw_params);

				if (err < 0) {

					SYSERR("snd_pcm_sw_params error");

					Pthread_mutex_unlock(&slave->mutex);

					return NULL;

				}

			}

			slave->polling = 1;

			Pthread_mutex_unlock(&slave->mutex);

			err = poll(pfd, 2, -1);

			Pthread_mutex_lock(&slave->mutex);

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

				char buf[1];

				read(pfd[0].fd, buf, 1);

			}

		} else {

			slave->polling = 0;

			pthread_cond_wait(&slave->poll_cond, &slave->mutex);

		}

	}

	Pthread_mutex_unlock(&slave->mutex);

	return NULL;

}

static void _snd_pcm_share_update(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_t *spcm = slave->pcm;

	snd_pcm_uframes_t missing;

	/* snd_pcm_sframes_t avail = */ snd_pcm_avail_update(spcm);

	slave->hw_ptr = *slave->pcm->hw.ptr;

	missing = _snd_pcm_share_missing(pcm);

	// printf("missing %ld\n", missing);

	if (!slave->polling) {

		pthread_cond_signal(&slave->poll_cond);

		return;

	}

	if (missing < INT_MAX) {

		snd_pcm_uframes_t hw_ptr;

		snd_pcm_sframes_t avail_min;

		hw_ptr = slave->hw_ptr + missing;

		hw_ptr += spcm->period_size - 1;

		if (hw_ptr >= spcm->boundary)

			hw_ptr -= spcm->boundary;

		hw_ptr -= hw_ptr % spcm->period_size;

		avail_min = hw_ptr - *spcm->appl.ptr;

		if (spcm->stream == SND_PCM_STREAM_PLAYBACK)

			avail_min += spcm->buffer_size;

		if (avail_min < 0)

			avail_min += spcm->boundary;

		if ((snd_pcm_uframes_t)avail_min < spcm->avail_min) {

			int err;

			snd_pcm_sw_params_set_avail_min(spcm, &slave->sw_params, avail_min);

			err = snd_pcm_sw_params(spcm, &slave->sw_params);

			if (err < 0) {

				SYSERR("snd_pcm_sw_params error");

				return;

			}

		}

	}

}

static int snd_pcm_share_nonblock(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int nonblock ATTRIBUTE_UNUSED)

{

	return 0;

}

static int snd_pcm_share_async(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int sig ATTRIBUTE_UNUSED, pid_t pid ATTRIBUTE_UNUSED)

{

	return -ENOSYS;

}

static int snd_pcm_share_info(snd_pcm_t *pcm, snd_pcm_info_t *info)

{

	snd_pcm_share_t *share = pcm->private_data;

	return snd_pcm_info(share->slave->pcm, info);

}

static int snd_pcm_share_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_access_mask_t access_mask;

	int err;

	snd_pcm_access_mask_any(&access_mask);

	snd_pcm_access_mask_reset(&access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);

	err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,

					 &access_mask);

	if (err < 0)

		return err;

	err = _snd_pcm_hw_param_set(params, SND_PCM_HW_PARAM_CHANNELS,

				    share->channels, 0);

	if (err < 0)

		return err;

	if (slave->format != SND_PCM_FORMAT_UNKNOWN) {

		err = _snd_pcm_hw_params_set_format(params, slave->format);

		if (err < 0)

			return err;

	}

	if (slave->rate >= 0) {

		err = _snd_pcm_hw_param_set(params, SND_PCM_HW_PARAM_RATE,

					    slave->rate, 0);

		if (err < 0)

			return err;

	}

	if (slave->period_time >= 0) {

		err = _snd_pcm_hw_param_set(params, SND_PCM_HW_PARAM_PERIOD_TIME,

					    slave->period_time, 0);

		if (err < 0)

			return err;

	}

	if (slave->buffer_time >= 0) {

		err = _snd_pcm_hw_param_set(params, SND_PCM_HW_PARAM_BUFFER_TIME,

					    slave->buffer_time, 0);

		if (err < 0)

			return err;

	}

	params->info |= SND_PCM_INFO_DOUBLE;

	return 0;

}

static int snd_pcm_share_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_access_mask_t saccess_mask = { SND_PCM_ACCBIT_MMAP };

	_snd_pcm_hw_params_any(sparams);

	_snd_pcm_hw_param_set_mask(sparams, SND_PCM_HW_PARAM_ACCESS,

				   &saccess_mask);

	_snd_pcm_hw_param_set(sparams, SND_PCM_HW_PARAM_CHANNELS,

			      slave->channels, 0);

	return 0;

}

static int snd_pcm_share_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params,

					  snd_pcm_hw_params_t *sparams)

{

	int err;

	unsigned int links = (SND_PCM_HW_PARBIT_FORMAT |

			      SND_PCM_HW_PARBIT_SUBFORMAT |

			      SND_PCM_HW_PARBIT_RATE |

			      SND_PCM_HW_PARBIT_PERIOD_SIZE |

			      SND_PCM_HW_PARBIT_PERIOD_TIME |

			      SND_PCM_HW_PARBIT_BUFFER_SIZE |

			      SND_PCM_HW_PARBIT_BUFFER_TIME |

			      SND_PCM_HW_PARBIT_PERIODS);

	const snd_pcm_access_mask_t *access_mask = snd_pcm_hw_param_get_mask(params, SND_PCM_HW_PARAM_ACCESS);

	if (!snd_pcm_access_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&

	    !snd_pcm_access_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&

	    !snd_pcm_access_mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {

		snd_pcm_access_mask_t saccess_mask;

		snd_pcm_access_mask_any(&saccess_mask);

		snd_pcm_access_mask_reset(&saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);

		err = _snd_pcm_hw_param_set_mask(sparams, SND_PCM_HW_PARAM_ACCESS,

						 &saccess_mask);

		if (err < 0)

			return err;

	}

	err = _snd_pcm_hw_params_refine(sparams, links, params);

	if (err < 0)

		return err;

	return 0;

}

static int snd_pcm_share_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params,

					   snd_pcm_hw_params_t *sparams)

{

	int err;

	unsigned int links = (SND_PCM_HW_PARBIT_FORMAT |

			      SND_PCM_HW_PARBIT_SUBFORMAT |

			      SND_PCM_HW_PARBIT_RATE |

			      SND_PCM_HW_PARBIT_PERIOD_SIZE |

			      SND_PCM_HW_PARBIT_PERIOD_TIME |

			      SND_PCM_HW_PARBIT_BUFFER_SIZE |

			      SND_PCM_HW_PARBIT_BUFFER_TIME |

			      SND_PCM_HW_PARBIT_PERIODS);

	snd_pcm_access_mask_t access_mask;

	const snd_pcm_access_mask_t *saccess_mask = snd_pcm_hw_param_get_mask(sparams, SND_PCM_HW_PARAM_ACCESS);

	snd_pcm_access_mask_any(&access_mask);

	snd_pcm_access_mask_reset(&access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);

	if (!snd_pcm_access_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))

		snd_pcm_access_mask_reset(&access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);

	if (!snd_pcm_access_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&

	    !snd_pcm_access_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))

		snd_pcm_access_mask_reset(&access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);

	err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,

					 &access_mask);

	if (err < 0)

		return err;

	err = _snd_pcm_hw_params_refine(params, links, sparams);

	if (err < 0)

		return err;

	return 0;

}

static int snd_pcm_share_hw_refine_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

{

	snd_pcm_share_t *share = pcm->private_data;

	return snd_pcm_hw_refine(share->slave->pcm, params);

}

static int snd_pcm_share_hw_params_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

{

	snd_pcm_share_t *share = pcm->private_data;

	return _snd_pcm_hw_params_internal(share->slave->pcm, params);

}

static int snd_pcm_share_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

{

	return snd_pcm_hw_refine_slave(pcm, params,

				       snd_pcm_share_hw_refine_cprepare,

				       snd_pcm_share_hw_refine_cchange,

				       snd_pcm_share_hw_refine_sprepare,

				       snd_pcm_share_hw_refine_schange,

				       snd_pcm_share_hw_refine_slave);

}

static int snd_pcm_share_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_t *spcm = slave->pcm;

	int err = 0;

	Pthread_mutex_lock(&slave->mutex);

	if (slave->setup_count) {

		err = _snd_pcm_hw_params_set_format(params, spcm->format);

		if (err < 0)

			goto _err;

		err = _snd_pcm_hw_params_set_subformat(params, spcm->subformat);

		if (err < 0)

			goto _err;

		err = _snd_pcm_hw_param_set_minmax(params, SND_PCM_HW_PARAM_RATE,

						   spcm->rate, 0, 

						   spcm->rate, 1);

		if (err < 0)

			goto _err;

		err = _snd_pcm_hw_param_set_minmax(params, SND_PCM_HW_PARAM_PERIOD_TIME,

						   spcm->period_time, 0,

						   spcm->period_time, 1);

		if (err < 0)

			goto _err;

		err = _snd_pcm_hw_param_set(params, SND_PCM_HW_PARAM_BUFFER_SIZE,

					    spcm->buffer_size, 0);

	_err:

		if (err < 0) {

			SNDERR("slave is already running with incompatible setup");

			err = -EBUSY;

			goto _end;

		}

	} else {

		err = snd_pcm_hw_params_slave(pcm, params,

					      snd_pcm_share_hw_refine_cchange,

					      snd_pcm_share_hw_refine_sprepare,

					      snd_pcm_share_hw_refine_schange,

					      snd_pcm_share_hw_params_slave);

		if (err < 0)

			goto _end;

		snd_pcm_sw_params_current(slave->pcm, &slave->sw_params);

		/* >= 30 ms */

		slave->safety_threshold = slave->pcm->rate * 30 / 1000;

		slave->safety_threshold += slave->pcm->period_size - 1;

		slave->safety_threshold -= slave->safety_threshold % slave->pcm->period_size;

		slave->silence_frames = slave->safety_threshold;

		if (slave->pcm->stream == SND_PCM_STREAM_PLAYBACK)

			snd_pcm_areas_silence(slave->pcm->running_areas, 0, slave->pcm->channels, slave->pcm->buffer_size, slave->pcm->format);

	}

	share->state = SND_PCM_STATE_SETUP;

	slave->setup_count++;

 _end:

	Pthread_mutex_unlock(&slave->mutex);

	return err;

}

static int snd_pcm_share_hw_free(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	int err = 0;

	Pthread_mutex_lock(&slave->mutex);

	slave->setup_count--;

	if (slave->setup_count == 0)

		err = snd_pcm_hw_free(slave->pcm);

	share->state = SND_PCM_STATE_OPEN;

	Pthread_mutex_unlock(&slave->mutex);

	return err;

}

static int snd_pcm_share_sw_params(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t *params ATTRIBUTE_UNUSED)

{

	return 0;

}

static int snd_pcm_share_status(snd_pcm_t *pcm, snd_pcm_status_t *status)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	int err = 0;

	snd_pcm_sframes_t sd = 0, d = 0;

	Pthread_mutex_lock(&slave->mutex);

	if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {

		status->avail = snd_pcm_mmap_playback_avail(pcm);

		if (share->state != SND_PCM_STATE_RUNNING &&

		    share->state != SND_PCM_STATE_DRAINING)

			goto _notrunning;

		d = pcm->buffer_size - status->avail;

	} else {

		status->avail = snd_pcm_mmap_capture_avail(pcm);

		if (share->state != SND_PCM_STATE_RUNNING)

			goto _notrunning;

		d = status->avail;

	}

	err = snd_pcm_delay(slave->pcm, &sd);

	if (err < 0)

		goto _end;

 _notrunning:

	status->delay = sd + d;

	status->state = share->state;

	status->appl_ptr = *pcm->appl.ptr;

	status->hw_ptr = *pcm->hw.ptr;

	status->trigger_tstamp = share->trigger_tstamp;

 _end:

	Pthread_mutex_unlock(&slave->mutex);

	return err;

}

static snd_pcm_state_t snd_pcm_share_state(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	return share->state;

}

static int _snd_pcm_share_hwsync(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	switch (share->state) {

	case SND_PCM_STATE_XRUN:

		return -EPIPE;

	default:

		break;

	}

	return snd_pcm_hwsync(slave->pcm);

}

static int snd_pcm_share_hwsync(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	int err;

	Pthread_mutex_lock(&slave->mutex);

	err = _snd_pcm_share_hwsync(pcm);

	Pthread_mutex_unlock(&slave->mutex);

	return err;

}

static int _snd_pcm_share_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	switch (share->state) {

	case SND_PCM_STATE_XRUN:

		return -EPIPE;

	case SND_PCM_STATE_RUNNING:

		break;

	case SND_PCM_STATE_DRAINING:

		if (pcm->stream == SND_PCM_STREAM_PLAYBACK)

			break;

		/* Fall through */

	default:

		return -EBADFD;

	}

	return snd_pcm_delay(slave->pcm, delayp);

}

static int snd_pcm_share_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	int err;

	Pthread_mutex_lock(&slave->mutex);

	err = _snd_pcm_share_delay(pcm, delayp);

	Pthread_mutex_unlock(&slave->mutex);

	return err;

}

static snd_pcm_sframes_t snd_pcm_share_avail_update(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_sframes_t avail;

	Pthread_mutex_lock(&slave->mutex);

	if (share->state == SND_PCM_STATE_RUNNING) {

		avail = snd_pcm_avail_update(slave->pcm);

		if (avail < 0) {

			Pthread_mutex_unlock(&slave->mutex);

			return avail;

		}

		share->hw_ptr = *slave->pcm->hw.ptr;

	}

	Pthread_mutex_unlock(&slave->mutex);

	avail = snd_pcm_mmap_avail(pcm);

	if ((snd_pcm_uframes_t)avail > pcm->buffer_size)

		return -EPIPE;

	return avail;

}

static int snd_pcm_share_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail,

				    snd_htimestamp_t *tstamp)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	int err;

	Pthread_mutex_lock(&slave->mutex);

	err = snd_pcm_htimestamp(slave->pcm, avail, tstamp);

	Pthread_mutex_unlock(&slave->mutex);

	return err;

}

/* Call it with mutex held */

static snd_pcm_sframes_t _snd_pcm_share_mmap_commit(snd_pcm_t *pcm,

						    snd_pcm_uframes_t offset ATTRIBUTE_UNUSED,

						    snd_pcm_uframes_t size)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_t *spcm = slave->pcm;

	snd_pcm_sframes_t ret;

	snd_pcm_sframes_t frames;

	if (pcm->stream == SND_PCM_STREAM_PLAYBACK &&

	    share->state == SND_PCM_STATE_RUNNING) {

		frames = *spcm->appl.ptr - share->appl_ptr;

		if (frames > (snd_pcm_sframes_t)pcm->buffer_size)

			frames -= pcm->boundary;

		else if (frames < -(snd_pcm_sframes_t)pcm->buffer_size)

			frames += pcm->boundary;

		if (frames > 0) {

			/* Latecomer PCM */

			ret = snd_pcm_rewind(spcm, frames);

			if (ret < 0)

				return ret;

		}

	}

	snd_pcm_mmap_appl_forward(pcm, size);

	if (share->state == SND_PCM_STATE_RUNNING) {

		frames = _snd_pcm_share_slave_forward(slave);

		if (frames > 0) {

			snd_pcm_sframes_t err;

			err = snd_pcm_mmap_commit(spcm, snd_pcm_mmap_offset(spcm), frames);

			if (err < 0) {

				SYSMSG("snd_pcm_mmap_commit error");

				return err;

			}

			if (err != frames) {

				SYSMSG("commit returns %ld for size %ld", err, frames);

				return err;

			}

		}

		_snd_pcm_share_update(pcm);

	}

	return size;

}

static snd_pcm_sframes_t snd_pcm_share_mmap_commit(snd_pcm_t *pcm,

						   snd_pcm_uframes_t offset,

						   snd_pcm_uframes_t size)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	snd_pcm_sframes_t ret;

	Pthread_mutex_lock(&slave->mutex);

	ret = _snd_pcm_share_mmap_commit(pcm, offset, size);

	Pthread_mutex_unlock(&slave->mutex);

	return ret;

}

static int snd_pcm_share_prepare(snd_pcm_t *pcm)

{

	snd_pcm_share_t *share = pcm->private_data;

	snd_pcm_share_slave_t *slave = share->slave;

	int err = 0;

	Pthread_mutex_lock(&slave->mutex);

	switch (share->state) {

	case SND_PCM_STATE_OPEN:

		err = -EBADFD;