/**

 * \file pcm/pcm_dmix.c

 * \ingroup PCM_Plugins

 * \brief PCM Direct Stream Mixing (dmix) Plugin Interface

 * \author Jaroslav Kysela <perex@perex.cz>

 * \date 2003

 */

/*

 *  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 <sys/shm.h>

#include <sys/sem.h>

#include <sys/wait.h>

#include <sys/socket.h>

#include <sys/un.h>

#include <sys/mman.h>

#include "pcm_direct.h"

#ifndef PIC

/* entry for static linking */

const char *_snd_module_pcm_dmix = "";

#endif

#ifndef DOC_HIDDEN

/* start is pending - this state happens when rate plugin does a delayed commit */

#define STATE_RUN_PENDING	1024

#endif

/*

 *

 */

static int shm_sum_discard(snd_pcm_direct_t *dmix);

/*

 *  sum ring buffer shared memory area 

 */

static int shm_sum_create_or_connect(snd_pcm_direct_t *dmix)

{

	struct shmid_ds buf;

	int tmpid, err;

	size_t size;

	size = dmix->shmptr->s.channels *

	       dmix->shmptr->s.buffer_size *

	       sizeof(signed int);	

retryshm:

	dmix->u.dmix.shmid_sum = shmget(dmix->ipc_key + 1, size,

					IPC_CREAT | dmix->ipc_perm);

	err = -errno;

	if (dmix->u.dmix.shmid_sum < 0) {

		if (errno == EINVAL)

		if ((tmpid = shmget(dmix->ipc_key + 1, 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 retryshm;

		return err;

	}

	if (shmctl(dmix->u.dmix.shmid_sum, IPC_STAT, &buf) < 0) {

		err = -errno;

		shm_sum_discard(dmix);

		return err;

	}

	if (dmix->ipc_gid >= 0) {

		buf.shm_perm.gid = dmix->ipc_gid;

		shmctl(dmix->u.dmix.shmid_sum, IPC_SET, &buf;; 

	}

	dmix->u.dmix.sum_buffer = shmat(dmix->u.dmix.shmid_sum, 0, 0);

	if (dmix->u.dmix.sum_buffer == (void *) -1) {

		err = -errno;

		shm_sum_discard(dmix);

		return err;

	}

	mlock(dmix->u.dmix.sum_buffer, size);

	return 0;

}

static int shm_sum_discard(snd_pcm_direct_t *dmix)

{

	struct shmid_ds buf;

	int ret = 0;

	if (dmix->u.dmix.shmid_sum < 0)

		return -EINVAL;

	if (dmix->u.dmix.sum_buffer != (void *) -1 && shmdt(dmix->u.dmix.sum_buffer) < 0)

		return -errno;

	dmix->u.dmix.sum_buffer = (void *) -1;

	if (shmctl(dmix->u.dmix.shmid_sum, IPC_STAT, &buf) < 0)

		return -errno;

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

		if (shmctl(dmix->u.dmix.shmid_sum, IPC_RMID, NULL) < 0)

			return -errno;

		ret = 1;

	}

	dmix->u.dmix.shmid_sum = -1;

	return ret;

}

static void dmix_server_free(snd_pcm_direct_t *dmix)

{

	/* remove the memory region */

	shm_sum_create_or_connect(dmix);

	shm_sum_discard(dmix);

}

/*

 *  the main function of this plugin: mixing

 *  FIXME: optimize it for different architectures

 */

#include "pcm_dmix_generic.c"

#if defined(__i386__)

#include "pcm_dmix_i386.c"

#elif defined(__x86_64__)

#include "pcm_dmix_x86_64.c"

#else

#ifndef DOC_HIDDEN

#define mix_select_callbacks(x)	generic_mix_select_callbacks(x)

#define dmix_supported_format generic_dmix_supported_format

#endif

#endif

static void mix_areas(snd_pcm_direct_t *dmix,

		      const snd_pcm_channel_area_t *src_areas,

		      const snd_pcm_channel_area_t *dst_areas,

		      snd_pcm_uframes_t src_ofs,

		      snd_pcm_uframes_t dst_ofs,

		      snd_pcm_uframes_t size)

{

	unsigned int src_step, dst_step;

	unsigned int chn, dchn, channels, sample_size;

	mix_areas_t *do_mix_areas;

	channels = dmix->channels;

	switch (dmix->shmptr->s.format) {

	case SND_PCM_FORMAT_S16_LE:

	case SND_PCM_FORMAT_S16_BE:

		sample_size = 2;

		do_mix_areas = (mix_areas_t *)dmix->u.dmix.mix_areas_16;

		break;

	case SND_PCM_FORMAT_S32_LE:

	case SND_PCM_FORMAT_S32_BE:

		sample_size = 4;

		do_mix_areas = (mix_areas_t *)dmix->u.dmix.mix_areas_32;

		break;

	case SND_PCM_FORMAT_S24_LE:

		sample_size = 4;

		do_mix_areas = (mix_areas_t *)dmix->u.dmix.mix_areas_24;

		break;

	case SND_PCM_FORMAT_S24_3LE:

		sample_size = 3;

		do_mix_areas = (mix_areas_t *)dmix->u.dmix.mix_areas_24;

		break;

	case SND_PCM_FORMAT_U8:

		sample_size = 1;

		do_mix_areas = (mix_areas_t *)dmix->u.dmix.mix_areas_u8;

		break;

	default:

		return;

	}

	if (dmix->interleaved) {

		/*

		 * process all areas in one loop

		 * it optimizes the memory accesses for this case

		 */

		do_mix_areas(size * channels,

			     (unsigned char *)dst_areas[0].addr + sample_size * dst_ofs * channels,

			     (unsigned char *)src_areas[0].addr + sample_size * src_ofs * channels,

			     dmix->u.dmix.sum_buffer + dst_ofs * channels,

			     sample_size,

			     sample_size,

			     sizeof(signed int));

		return;

	}

	for (chn = 0; chn < channels; chn++) {

		dchn = dmix->bindings ? dmix->bindings[chn] : chn;

		if (dchn >= dmix->shmptr->s.channels)

			continue;

		src_step = src_areas[chn].step / 8;

		dst_step = dst_areas[dchn].step / 8;

		do_mix_areas(size,

			     ((unsigned char *)dst_areas[dchn].addr + dst_areas[dchn].first / 8) + dst_ofs * dst_step,

			     ((unsigned char *)src_areas[chn].addr + src_areas[chn].first / 8) + src_ofs * src_step,

			     dmix->u.dmix.sum_buffer + channels * dst_ofs + chn,

			     dst_step,

			     src_step,

			     channels * sizeof(signed int));

	}

}

static void remix_areas(snd_pcm_direct_t *dmix,

			const snd_pcm_channel_area_t *src_areas,

			const snd_pcm_channel_area_t *dst_areas,

			snd_pcm_uframes_t src_ofs,

			snd_pcm_uframes_t dst_ofs,

			snd_pcm_uframes_t size)

{

	unsigned int src_step, dst_step;

	unsigned int chn, dchn, channels, sample_size;

	mix_areas_t *do_remix_areas;

	channels = dmix->channels;

	switch (dmix->shmptr->s.format) {

	case SND_PCM_FORMAT_S16_LE:

	case SND_PCM_FORMAT_S16_BE:

		sample_size = 2;

		do_remix_areas = (mix_areas_t *)dmix->u.dmix.remix_areas_16;

		break;

	case SND_PCM_FORMAT_S32_LE:

	case SND_PCM_FORMAT_S32_BE:

		sample_size = 4;

		do_remix_areas = (mix_areas_t *)dmix->u.dmix.remix_areas_32;

		break;

	case SND_PCM_FORMAT_S24_LE:

		sample_size = 4;

		do_remix_areas = (mix_areas_t *)dmix->u.dmix.remix_areas_24;

		break;

	case SND_PCM_FORMAT_S24_3LE:

		sample_size = 3;

		do_remix_areas = (mix_areas_t *)dmix->u.dmix.remix_areas_24;

		break;

	case SND_PCM_FORMAT_U8:

		sample_size = 1;

		do_remix_areas = (mix_areas_t *)dmix->u.dmix.remix_areas_u8;

		break;

	default:

		return;

	}

	if (dmix->interleaved) {

		/*

		 * process all areas in one loop

		 * it optimizes the memory accesses for this case

		 */

		do_remix_areas(size * channels,

			       (unsigned char *)dst_areas[0].addr + sample_size * dst_ofs * channels,

			       (unsigned char *)src_areas[0].addr + sample_size * src_ofs * channels,

			       dmix->u.dmix.sum_buffer + dst_ofs * channels,

			       sample_size,

			       sample_size,

			       sizeof(signed int));

		return;

	}

	for (chn = 0; chn < channels; chn++) {

		dchn = dmix->bindings ? dmix->bindings[chn] : chn;

		if (dchn >= dmix->shmptr->s.channels)

			continue;

		src_step = src_areas[chn].step / 8;

		dst_step = dst_areas[dchn].step / 8;

		do_remix_areas(size,

			       ((unsigned char *)dst_areas[dchn].addr + dst_areas[dchn].first / 8) + dst_ofs * dst_step,

			       ((unsigned char *)src_areas[chn].addr + src_areas[chn].first / 8) + src_ofs * src_step,

			       dmix->u.dmix.sum_buffer + channels * dst_ofs + chn,

			       dst_step,

			       src_step,

			       channels * sizeof(signed int));

	}

}

/*

 * if no concurrent access is allowed in the mixing routines, we need to protect

 * the area via semaphore

 */

#ifndef DOC_HIDDEN

#ifdef NO_CONCURRENT_ACCESS

#define dmix_down_sem(dmix) snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT)

#define dmix_up_sem(dmix) snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT)

#else

#define dmix_down_sem(dmix)

#define dmix_up_sem(dmix)

#endif

#endif

/*

 *  synchronize shm ring buffer with hardware

 */

static void snd_pcm_dmix_sync_area(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	snd_pcm_uframes_t slave_hw_ptr, slave_appl_ptr, slave_size;

	snd_pcm_uframes_t appl_ptr, size, transfer;

	const snd_pcm_channel_area_t *src_areas, *dst_areas;

	/* calculate the size to transfer */

	/* check the available size in the local buffer

	 * last_appl_ptr keeps the last updated position

	 */

	size = dmix->appl_ptr - dmix->last_appl_ptr;

	if (! size)

		return;

	if (size >= pcm->boundary / 2)

		size = pcm->boundary - size;

	/* the slave_app_ptr can be far behind the slave_hw_ptr */

	/* reduce mixing and errors here - just skip not catched writes */

	if (dmix->slave_hw_ptr <= dmix->slave_appl_ptr)

		slave_size = dmix->slave_appl_ptr - dmix->slave_hw_ptr;

	else

		slave_size = dmix->slave_appl_ptr + (dmix->slave_boundary - dmix->slave_hw_ptr);

	if (slave_size > dmix->slave_buffer_size) {

		transfer = dmix->slave_buffer_size - slave_size;

		if (transfer > size)

			transfer = size;

		dmix->last_appl_ptr += transfer;

		dmix->last_appl_ptr %= pcm->boundary;

		dmix->slave_appl_ptr += transfer;

		dmix->slave_appl_ptr %= dmix->slave_boundary;

		size = dmix->appl_ptr - dmix->last_appl_ptr;

		if (! size)

			return;

		if (size >= pcm->boundary / 2)

			size = pcm->boundary - size;

	}

	/* check the available size in the slave PCM buffer */

	slave_hw_ptr = dmix->slave_hw_ptr;

	/* don't write on the last active period - this area may be cleared

	 * by the driver during mix operation...

	 */

	slave_hw_ptr -= slave_hw_ptr % dmix->slave_period_size;

	slave_hw_ptr += dmix->slave_buffer_size;

	if (slave_hw_ptr >= dmix->slave_boundary)

		slave_hw_ptr -= dmix->slave_boundary;

	if (slave_hw_ptr < dmix->slave_appl_ptr)

		slave_size = slave_hw_ptr + (dmix->slave_boundary - dmix->slave_appl_ptr);

	else

		slave_size = slave_hw_ptr - dmix->slave_appl_ptr;

	if (slave_size < size)

		size = slave_size;

	if (! size)

		return;

	/* add sample areas here */

	src_areas = snd_pcm_mmap_areas(pcm);

	dst_areas = snd_pcm_mmap_areas(dmix->spcm);

	appl_ptr = dmix->last_appl_ptr % pcm->buffer_size;

	dmix->last_appl_ptr += size;

	dmix->last_appl_ptr %= pcm->boundary;

	slave_appl_ptr = dmix->slave_appl_ptr % dmix->slave_buffer_size;

	dmix->slave_appl_ptr += size;

	dmix->slave_appl_ptr %= dmix->slave_boundary;

	dmix_down_sem(dmix);

	for (;;) {

		transfer = size;

		if (appl_ptr + transfer > pcm->buffer_size)

			transfer = pcm->buffer_size - appl_ptr;

		if (slave_appl_ptr + transfer > dmix->slave_buffer_size)

			transfer = dmix->slave_buffer_size - slave_appl_ptr;

		mix_areas(dmix, src_areas, dst_areas, appl_ptr, slave_appl_ptr, transfer);

		size -= transfer;

		if (! size)

			break;

		slave_appl_ptr += transfer;

		slave_appl_ptr %= dmix->slave_buffer_size;

		appl_ptr += transfer;

		appl_ptr %= pcm->buffer_size;

	}

	dmix_up_sem(dmix);

}

/*

 *  synchronize hardware pointer (hw_ptr) with ours

 */

static int snd_pcm_dmix_sync_ptr0(snd_pcm_t *pcm, snd_pcm_uframes_t slave_hw_ptr)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	snd_pcm_uframes_t old_slave_hw_ptr, avail;

	snd_pcm_sframes_t diff;

	old_slave_hw_ptr = dmix->slave_hw_ptr;

	dmix->slave_hw_ptr = slave_hw_ptr;

	diff = slave_hw_ptr - old_slave_hw_ptr;

	if (diff == 0)		/* fast path */

		return 0;

	if (dmix->state != SND_PCM_STATE_RUNNING &&

	    dmix->state != SND_PCM_STATE_DRAINING)

		/* not really started yet - don't update hw_ptr */

		return 0;

	if (diff < 0) {

		slave_hw_ptr += dmix->slave_boundary;

		diff = slave_hw_ptr - old_slave_hw_ptr;

	}

	dmix->hw_ptr += diff;

	dmix->hw_ptr %= pcm->boundary;

	if (pcm->stop_threshold >= pcm->boundary)	/* don't care */

		return 0;

	avail = snd_pcm_mmap_playback_avail(pcm);

	if (avail > dmix->avail_max)

		dmix->avail_max = avail;

	if (avail >= pcm->stop_threshold) {

		snd_timer_stop(dmix->timer);

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

		if (dmix->state == SND_PCM_STATE_RUNNING) {

			dmix->state = SND_PCM_STATE_XRUN;

			return -EPIPE;

		}

		dmix->state = SND_PCM_STATE_SETUP;

		/* clear queue to remove pending poll events */

		snd_pcm_direct_clear_timer_queue(dmix);

	}

	return 0;

}

static int snd_pcm_dmix_sync_ptr(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	int err;

	switch (snd_pcm_state(dmix->spcm)) {

	case SND_PCM_STATE_DISCONNECTED:

		dmix->state = SND_PCM_STATE_DISCONNECTED;

		return -ENODEV;

	case SND_PCM_STATE_XRUN:

		if ((err = snd_pcm_direct_slave_recover(dmix)) < 0)

			return err;

		break;

	default:

		break;

	}

	if (snd_pcm_direct_client_chk_xrun(dmix, pcm))

		return -EPIPE;

	if (dmix->slowptr)

		snd_pcm_hwsync(dmix->spcm);

	return snd_pcm_dmix_sync_ptr0(pcm, *dmix->spcm->hw.ptr);

}

/*

 *  plugin implementation

 */

static snd_pcm_state_t snd_pcm_dmix_state(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	int err;

	snd_pcm_state_t state;

	state = snd_pcm_state(dmix->spcm);

	switch (state) {

	case SND_PCM_STATE_SUSPENDED:

	case SND_PCM_STATE_DISCONNECTED:

		dmix->state = state;

		return state;

	case SND_PCM_STATE_XRUN:

		if ((err = snd_pcm_direct_slave_recover(dmix)) < 0)

			return err;

		break;

	default:

		break;

	}

	snd_pcm_direct_client_chk_xrun(dmix, pcm);

	if (dmix->state == STATE_RUN_PENDING)

		return SNDRV_PCM_STATE_RUNNING;

	return dmix->state;

}

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

{

	snd_pcm_direct_t *dmix = pcm->private_data;

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

	snd_pcm_status(dmix->spcm, status);

	switch (dmix->state) {

	case SNDRV_PCM_STATE_DRAINING:

	case SNDRV_PCM_STATE_RUNNING:

		snd_pcm_dmix_sync_ptr0(pcm, status->hw_ptr);

		status->delay += snd_pcm_mmap_playback_delay(pcm)

				+ status->avail - dmix->spcm->buffer_size;

		break;

	default:

		break;

	}

	status->state = snd_pcm_dmix_state(pcm);

	status->trigger_tstamp = dmix->trigger_tstamp;

	status->avail = snd_pcm_mmap_playback_avail(pcm);

	status->avail_max = status->avail > dmix->avail_max ? status->avail : dmix->avail_max;

	dmix->avail_max = 0;

	return 0;

}

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

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	int err;

	switch(dmix->state) {

	case SNDRV_PCM_STATE_DRAINING:

	case SNDRV_PCM_STATE_RUNNING:

		err = snd_pcm_dmix_sync_ptr(pcm);

		if (err < 0)

			return err;

		/* fallthru */

	case SNDRV_PCM_STATE_PREPARED:

	case SNDRV_PCM_STATE_SUSPENDED:

	case STATE_RUN_PENDING:

		*delayp = snd_pcm_mmap_playback_hw_avail(pcm);

		return 0;

	case SNDRV_PCM_STATE_XRUN:

		return -EPIPE;

	case SNDRV_PCM_STATE_DISCONNECTED:

		return -ENODEV;

	default:

		return -EBADFD;

	}

}

static int snd_pcm_dmix_hwsync(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	switch(dmix->state) {

	case SNDRV_PCM_STATE_DRAINING:

	case SNDRV_PCM_STATE_RUNNING:

		/* sync slave PCM */

		return snd_pcm_dmix_sync_ptr(pcm);

	case SNDRV_PCM_STATE_PREPARED:

	case SNDRV_PCM_STATE_SUSPENDED:

	case STATE_RUN_PENDING:

		return 0;

	case SNDRV_PCM_STATE_XRUN:

		return -EPIPE;

	case SNDRV_PCM_STATE_DISCONNECTED:

		return -ENODEV;

	default:

		return -EBADFD;

	}

}

static int snd_pcm_dmix_reset(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	dmix->hw_ptr %= pcm->period_size;

	dmix->appl_ptr = dmix->last_appl_ptr = dmix->hw_ptr;

	dmix->slave_appl_ptr = dmix->slave_hw_ptr = *dmix->spcm->hw.ptr;

	snd_pcm_direct_reset_slave_ptr(pcm, dmix);

	return 0;

}

static int snd_pcm_dmix_start_timer(snd_pcm_t *pcm, snd_pcm_direct_t *dmix)

{

	int err;

	snd_pcm_hwsync(dmix->spcm);

	dmix->slave_appl_ptr = dmix->slave_hw_ptr = *dmix->spcm->hw.ptr;

	snd_pcm_direct_reset_slave_ptr(pcm, dmix);

	err = snd_timer_start(dmix->timer);

	if (err < 0)

		return err;

	dmix->state = SND_PCM_STATE_RUNNING;

	return 0;

}

static int snd_pcm_dmix_start(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	snd_pcm_sframes_t avail;

	int err;

	if (dmix->state != SND_PCM_STATE_PREPARED)

		return -EBADFD;

	avail = snd_pcm_mmap_playback_hw_avail(pcm);

	if (avail == 0)

		dmix->state = STATE_RUN_PENDING;

	else if (avail < 0)

		return 0;

	else {

		if ((err = snd_pcm_dmix_start_timer(pcm, dmix)) < 0)

			return err;

		snd_pcm_dmix_sync_area(pcm);

	}

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

	return 0;

}

static int snd_pcm_dmix_drop(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	if (dmix->state == SND_PCM_STATE_OPEN)

		return -EBADFD;

	dmix->state = SND_PCM_STATE_SETUP;

	snd_pcm_direct_timer_stop(dmix);

	return 0;

}

/* locked version */

static int __snd_pcm_dmix_drain(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	snd_pcm_uframes_t stop_threshold;

	int err = 0;

	switch (snd_pcm_state(dmix->spcm)) {

	case SND_PCM_STATE_SUSPENDED:

		return -ESTRPIPE;

	default:

		break;

	}

	if (dmix->state == SND_PCM_STATE_OPEN)

		return -EBADFD;

	if (dmix->state == SND_PCM_STATE_PREPARED) {

		if (snd_pcm_mmap_playback_hw_avail(pcm) > 0)

			snd_pcm_dmix_start(pcm);

		else {

			snd_pcm_dmix_drop(pcm);

			return 0;

		}

	}

	if (dmix->state == SND_PCM_STATE_XRUN) {

		snd_pcm_dmix_drop(pcm);

		return 0;

	}

	stop_threshold = pcm->stop_threshold;

	if (pcm->stop_threshold > pcm->buffer_size)

		pcm->stop_threshold = pcm->buffer_size;

	dmix->state = SND_PCM_STATE_DRAINING;

	do {

		err = snd_pcm_dmix_sync_ptr(pcm);

		if (err < 0) {

			snd_pcm_dmix_drop(pcm);

			goto done;

		}

		if (dmix->state == SND_PCM_STATE_DRAINING) {

			snd_pcm_dmix_sync_area(pcm);

			if ((pcm->mode & SND_PCM_NONBLOCK) == 0) {

				snd_pcm_wait_nocheck(pcm, -1);

				snd_pcm_direct_clear_timer_queue(dmix); /* force poll to wait */

			}

			switch (snd_pcm_state(dmix->spcm)) {

			case SND_PCM_STATE_SUSPENDED:

				err = -ESTRPIPE;

				goto done;

			default:

				break;

			}

		}

		if (pcm->mode & SND_PCM_NONBLOCK) {

			if (dmix->state == SND_PCM_STATE_DRAINING) {

				err = -EAGAIN;

				goto done;

			}

		}

	} while (dmix->state == SND_PCM_STATE_DRAINING);

done:

	pcm->stop_threshold = stop_threshold;

	return err;

}

static int snd_pcm_dmix_drain(snd_pcm_t *pcm)

{

	int err;

	snd_pcm_lock(pcm);

	err = __snd_pcm_dmix_drain(pcm);

	snd_pcm_unlock(pcm);

	return err;

}

static int snd_pcm_dmix_pause(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int enable ATTRIBUTE_UNUSED)

{

	return -EIO;

}

static snd_pcm_sframes_t snd_pcm_dmix_rewindable(snd_pcm_t *pcm)

{

	return snd_pcm_mmap_playback_hw_rewindable(pcm);

}

static snd_pcm_sframes_t snd_pcm_dmix_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	snd_pcm_uframes_t slave_appl_ptr, slave_size;

	snd_pcm_uframes_t appl_ptr, size, transfer, result, frames_to_remix;

	int err;

	const snd_pcm_channel_area_t *src_areas, *dst_areas;

	if (dmix->state == SND_PCM_STATE_RUNNING ||

	    dmix->state == SND_PCM_STATE_DRAINING) {

		err = snd_pcm_dmix_hwsync(pcm);

		if (err < 0)

			return err;

	}

	/* (appl_ptr - last_appl_ptr) indicates the frames which are not

	 * already mixed

	 * (last_appl_ptr - hw_ptr)  indicates the frames which are already

	 * mixed but not played yet.

	 * So they can be remixed.

	 */

	if (dmix->last_appl_ptr < dmix->appl_ptr)

		size = dmix->appl_ptr - dmix->last_appl_ptr;

	else

		size = dmix->appl_ptr + (pcm->boundary - dmix->last_appl_ptr);

	if (frames < size)

		size = frames;

	snd_pcm_mmap_appl_backward(pcm, size);

	frames -= size;

	if (!frames)

		return size;

	result = size;

	/* Always at this point last_appl_ptr == appl_ptr

	 * So (appl_ptr - hw_ptr) indicates the frames which can be remixed

	 */

	if (dmix->hw_ptr < dmix->appl_ptr)

		size = dmix->appl_ptr - dmix->hw_ptr;

	else

		size = dmix->appl_ptr + (pcm->boundary - dmix->hw_ptr);

	if (size > frames)

		size = frames;

	if (dmix->slave_hw_ptr < dmix->slave_appl_ptr)

		slave_size = dmix->slave_appl_ptr - dmix->slave_hw_ptr;

	else

		slave_size = dmix->slave_appl_ptr + (pcm->boundary - dmix->slave_hw_ptr);

	if (slave_size < size)

		size = slave_size;

	/* frames which should be remixed will be saved

	 * to also backward the appl pointer on success

	 */

	frames_to_remix = size;

	/* add sample areas here */

	src_areas = snd_pcm_mmap_areas(pcm);

	dst_areas = snd_pcm_mmap_areas(dmix->spcm);

	dmix->last_appl_ptr -= size;

	dmix->last_appl_ptr %= pcm->boundary;

	appl_ptr = dmix->last_appl_ptr % pcm->buffer_size;

	dmix->slave_appl_ptr -= size;

	dmix->slave_appl_ptr %= dmix->slave_boundary;

	slave_appl_ptr = dmix->slave_appl_ptr % dmix->slave_buffer_size;

	dmix_down_sem(dmix);

	for (;;) {

		transfer = size;

		if (appl_ptr + transfer > pcm->buffer_size)

			transfer = pcm->buffer_size - appl_ptr;

		if (slave_appl_ptr + transfer > dmix->slave_buffer_size)

			transfer = dmix->slave_buffer_size - slave_appl_ptr;

		remix_areas(dmix, src_areas, dst_areas, appl_ptr, slave_appl_ptr, transfer);

		size -= transfer;

		if (! size)

			break;

		slave_appl_ptr += transfer;

		slave_appl_ptr %= dmix->slave_buffer_size;

		appl_ptr += transfer;

		appl_ptr %= pcm->buffer_size;

	}

	dmix_up_sem(dmix);

	snd_pcm_mmap_appl_backward(pcm, frames_to_remix);

	result += frames_to_remix;

	/* At this point last_appl_ptr and appl_ptr has to indicate the

	 * position of the first not mixed frame

	 */

	return result;

}

static snd_pcm_sframes_t snd_pcm_dmix_forwardable(snd_pcm_t *pcm)

{

	return snd_pcm_mmap_avail(pcm);

}

static snd_pcm_sframes_t snd_pcm_dmix_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames)

{

	snd_pcm_sframes_t avail;

	avail = snd_pcm_dmix_forwardable(pcm);

	if (frames > (snd_pcm_uframes_t)avail)

		frames = avail;

	snd_pcm_mmap_appl_forward(pcm, frames);

	return frames;

}

static snd_pcm_sframes_t snd_pcm_dmix_readi(snd_pcm_t *pcm ATTRIBUTE_UNUSED, void *buffer ATTRIBUTE_UNUSED, snd_pcm_uframes_t size ATTRIBUTE_UNUSED)

{

	return -ENODEV;

}

static snd_pcm_sframes_t snd_pcm_dmix_readn(snd_pcm_t *pcm ATTRIBUTE_UNUSED, void **bufs ATTRIBUTE_UNUSED, snd_pcm_uframes_t size ATTRIBUTE_UNUSED)

{

	return -ENODEV;

}

static int snd_pcm_dmix_close(snd_pcm_t *pcm)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	if (dmix->timer)

		snd_timer_close(dmix->timer);

	snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT);

	snd_pcm_close(dmix->spcm);

 	if (dmix->server)

 		snd_pcm_direct_server_discard(dmix);

 	if (dmix->client)

 		snd_pcm_direct_client_discard(dmix);

 	shm_sum_discard(dmix);

	if (snd_pcm_direct_shm_discard(dmix)) {

		if (snd_pcm_direct_semaphore_discard(dmix))

			snd_pcm_direct_semaphore_final(dmix, DIRECT_IPC_SEM_CLIENT);

	} else

		snd_pcm_direct_semaphore_final(dmix, DIRECT_IPC_SEM_CLIENT);

	free(dmix->bindings);

	pcm->private_data = NULL;

	free(dmix);

	return 0;

}

static snd_pcm_sframes_t snd_pcm_dmix_mmap_commit(snd_pcm_t *pcm,

						  snd_pcm_uframes_t offset ATTRIBUTE_UNUSED,

						  snd_pcm_uframes_t size)

{

	snd_pcm_direct_t *dmix = pcm->private_data;

	int err;

	switch (snd_pcm_state(dmix->spcm)) {

	case SND_PCM_STATE_XRUN:

		if ((err = snd_pcm_direct_slave_recover(dmix)) < 0)

			return err;

		break;

	case SND_PCM_STATE_SUSPENDED:

		return -ESTRPIPE;

	default:

		break;

	}

	if (snd_pcm_direct_client_chk_xrun(dmix, pcm))

		return -EPIPE;

	if (! size)

		return 0;

	snd_pcm_mmap_appl_forward(pcm, size);

	if (dmix->state == STATE_RUN_PENDING) {

		if ((err = snd_pcm_dmix_start_timer(pcm, dmix)) < 0)

			return err;

	} else if (dmix->state == SND_PCM_STATE_RUNNING ||

		   dmix->state == SND_PCM_STATE_DRAINING) {

		if ((err = snd_pcm_dmix_sync_ptr(pcm)) < 0)

			return err;

	}

	if (dmix->state == SND_PCM_STATE_RUNNING ||

	    dmix->state == SND_PCM_STATE_DRAINING) {

		/* ok, we commit the changes after the validation of area */

		/* it's intended, although the result might be crappy */

		snd_pcm_dmix_sync_area(pcm);

		/* clear timer queue to avoid a bogus return from poll */

		if (snd_pcm_mmap_playback_avail(pcm) < pcm->avail_min)