/**

 * \file pcm/pcm_multi.c

 * \ingroup PCM_Plugins

 * \brief PCM Multi Streams to One Conversion Plugin Interface

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

 * \date 2000-2001

 */

/*

 *  PCM - Multi

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

#include <string.h>

#include <math.h>

#include "pcm_local.h"

#include "pcm_generic.h"

#ifndef PIC

/* entry for static linking */

const char *_snd_module_pcm_multi = "";

#endif

#ifndef DOC_HIDDEN

typedef struct {

	snd_pcm_t *pcm;

	unsigned int channels_count;

	int close_slave;

	snd_pcm_t *linked;

} snd_pcm_multi_slave_t;

typedef struct {

	int slave_idx;

	unsigned int slave_channel;

} snd_pcm_multi_channel_t;

typedef struct {

	snd_pcm_uframes_t appl_ptr, hw_ptr;

	unsigned int slaves_count;

	unsigned int master_slave;

	snd_pcm_multi_slave_t *slaves;

	unsigned int channels_count;

	snd_pcm_multi_channel_t *channels;

} snd_pcm_multi_t;

#endif

static int snd_pcm_multi_close(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	int ret = 0;

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_multi_slave_t *slave = &multi->slaves[i];

		if (slave->close_slave) {

			int err = snd_pcm_close(slave->pcm);

			if (err < 0)

				ret = err;

		}

	}

	free(multi->slaves);

	free(multi->channels);

	free(multi);

	return ret;

}

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

{

	return 0;

}

static int snd_pcm_multi_async(snd_pcm_t *pcm, int sig, pid_t pid)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave_0 = multi->slaves[multi->master_slave].pcm;

	return snd_pcm_async(slave_0, sig, pid);

}

static int snd_pcm_multi_poll_descriptors_count(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave_0 = multi->slaves[multi->master_slave].pcm;

	return snd_pcm_poll_descriptors_count(slave_0);

}

static int snd_pcm_multi_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int space)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave;

	snd_pcm_t *slave_0 = multi->slaves[multi->master_slave].pcm;

	int err;

	unsigned int i;

	for (i = 0; i < multi->slaves_count; ++i) {

		slave = multi->slaves[i].pcm;

		if (slave == slave_0)

			continue;

		err = snd_pcm_poll_descriptors(slave, pfds, space);

		if (err < 0)

			return err;

	}

	/* finally overwrite with master's pfds */

	return snd_pcm_poll_descriptors(slave_0, pfds, space);

}

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

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave_0 = multi->slaves[multi->master_slave].pcm;

	return snd_pcm_poll_descriptors_revents(slave_0, pfds, nfds, revents);

}

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

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int err, n;

	assert(info->subdevice < multi->slaves_count);

	n = info->subdevice;

	info->subdevice = 0;

	err = snd_pcm_info(multi->slaves[n].pcm, info);

	if (err < 0)

		return err;

	info->subdevices_count = multi->slaves_count;

	return 0;

}

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

{

	snd_pcm_multi_t *multi = pcm->private_data;

	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,

				    multi->channels_count, 0);

	if (err < 0)

		return err;

	params->info = ~0U;

	return 0;

}

static int snd_pcm_multi_hw_refine_sprepare(snd_pcm_t *pcm, unsigned int slave_idx,

					    snd_pcm_hw_params_t *sparams)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_multi_slave_t *slave = &multi->slaves[slave_idx];

	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_count, 0);

	return 0;

}

static int snd_pcm_multi_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,

					   unsigned int slave_idx 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_PERIODS |

			      SND_PCM_HW_PARBIT_BUFFER_SIZE |

			      SND_PCM_HW_PARBIT_BUFFER_TIME |

			      SND_PCM_HW_PARBIT_TICK_TIME);

	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_multi_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,

					   unsigned int slave_idx 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_PERIODS |

			      SND_PCM_HW_PARBIT_BUFFER_SIZE |

			      SND_PCM_HW_PARBIT_BUFFER_TIME |

			      SND_PCM_HW_PARBIT_TICK_TIME);

	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;

	params->info &= sparams->info;

	return 0;

}

static int snd_pcm_multi_hw_refine_slave(snd_pcm_t *pcm,

					 unsigned int slave_idx,

					 snd_pcm_hw_params_t *sparams)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave = multi->slaves[slave_idx].pcm;

	return snd_pcm_hw_refine(slave, sparams);

}

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

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int k;

	snd_pcm_hw_params_t sparams[multi->slaves_count];

	int err;

	unsigned int cmask, changed;

	err = snd_pcm_multi_hw_refine_cprepare(pcm, params);

	if (err < 0)

		return err;

	for (k = 0; k < multi->slaves_count; ++k) {

		err = snd_pcm_multi_hw_refine_sprepare(pcm, k, &sparams[k]);

		if (err < 0) {

			SNDERR("Slave PCM #%d not usable", k);

			return err;

		}

	}

	do {

		cmask = params->cmask;

		params->cmask = 0;

		for (k = 0; k < multi->slaves_count; ++k) {

			err = snd_pcm_multi_hw_refine_schange(pcm, k, params, &sparams[k]);

			if (err >= 0)

				err = snd_pcm_multi_hw_refine_slave(pcm, k, &sparams[k]);

			if (err < 0) {

				snd_pcm_multi_hw_refine_cchange(pcm, k, params, &sparams[k]);

				return err;

			}

			err = snd_pcm_multi_hw_refine_cchange(pcm, k, params, &sparams[k]);

			if (err < 0)

				return err;

		}

		err = snd_pcm_hw_refine_soft(pcm, params);

		changed = params->cmask;

		params->cmask |= cmask;

		if (err < 0)

			return err;

	} while (changed);

	return 0;

}

static int snd_pcm_multi_hw_params_slave(snd_pcm_t *pcm,

					 unsigned int slave_idx,

					 snd_pcm_hw_params_t *sparams)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave = multi->slaves[slave_idx].pcm;

	int err = snd_pcm_hw_params(slave, sparams);

	if (err < 0)

		return err;

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

	if (err < 0)

		return err;

	if (slave->stopped_areas) {

		err = snd_pcm_areas_silence(slave->stopped_areas, 0, slave->channels, slave->buffer_size, slave->format);

		if (err < 0)

			return err;

	}

	return 0;

}

/* reset links to the normal state

 * slave #0 = trigger master

 * slave #1-(N-1) = trigger slaves, linked is set to #0

 */

static void reset_links(snd_pcm_multi_t *multi)

{

	unsigned int i;

	for (i = 0; i < multi->slaves_count; ++i) {

		if (multi->slaves[i].linked)

			snd_pcm_unlink(multi->slaves[i].linked);

		multi->slaves[0].linked = NULL;

		if (! i)

			continue;

		if (snd_pcm_link(multi->slaves[0].pcm, multi->slaves[i].pcm) >= 0)

			multi->slaves[i].linked = multi->slaves[0].pcm;

	}

}

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

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	snd_pcm_hw_params_t sparams[multi->slaves_count];

	int err;

	for (i = 0; i < multi->slaves_count; ++i) {

		err = snd_pcm_multi_hw_refine_sprepare(pcm, i, &sparams[i]);

		assert(err >= 0);

		err = snd_pcm_multi_hw_refine_schange(pcm, i, params, &sparams[i]);

		assert(err >= 0);

		err = snd_pcm_multi_hw_params_slave(pcm, i, &sparams[i]);

		if (err < 0) {

			snd_pcm_multi_hw_refine_cchange(pcm, i, params, &sparams[i]);

			return err;

		}

	}

	reset_links(multi);

	return 0;

}

static int snd_pcm_multi_hw_free(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	int err = 0;

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_t *slave = multi->slaves[i].pcm;

		int e = snd_pcm_hw_free(slave);

		if (e < 0)

			err = e;

		if (!multi->slaves[i].linked)

			continue;

		e = snd_pcm_unlink(slave);

		if (e < 0)

			err = e;

		multi->slaves[i].linked = NULL;

	}

	return err;

}

static int snd_pcm_multi_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	int err;

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_t *slave = multi->slaves[i].pcm;

		err = snd_pcm_sw_params(slave, params);

		if (err < 0)

			return err;

	}

	return 0;

}

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

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave = multi->slaves[multi->master_slave].pcm;

	return snd_pcm_status(slave, status);

}

static snd_pcm_state_t snd_pcm_multi_state(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave = multi->slaves[multi->master_slave].pcm;

	return snd_pcm_state(slave);

}

static void snd_pcm_multi_hwptr_update(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_uframes_t hw_ptr = 0, slave_hw_ptr, avail, last_avail;

	unsigned int i;

	/* the logic is really simple, choose the lowest hw_ptr from slaves */

	if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {

		last_avail = 0;

		for (i = 0; i < multi->slaves_count; ++i) {

			slave_hw_ptr = *multi->slaves[i].pcm->hw.ptr;

			avail = __snd_pcm_playback_avail(pcm, multi->hw_ptr, slave_hw_ptr);

			if (avail > last_avail) {

				hw_ptr = slave_hw_ptr;

				last_avail = avail;

			}

		}

	} else {

		last_avail = LONG_MAX;

		for (i = 0; i < multi->slaves_count; ++i) {

			slave_hw_ptr = *multi->slaves[i].pcm->hw.ptr;

			avail = __snd_pcm_capture_avail(pcm, multi->hw_ptr, slave_hw_ptr);

			if (avail < last_avail) {

				hw_ptr = slave_hw_ptr;

				last_avail = avail;

			}

		}

	}

	multi->hw_ptr = hw_ptr;

}

static int snd_pcm_multi_hwsync(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	int err;

	for (i = 0; i < multi->slaves_count; ++i) {

		err = snd_pcm_hwsync(multi->slaves[i].pcm);

		if (err < 0)

			return err;

	}

	snd_pcm_multi_hwptr_update(pcm);

	return 0;

}

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

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_sframes_t d, dr = 0;

	unsigned int i;

	int err;

	for (i = 0; i < multi->slaves_count; ++i) {

		err = snd_pcm_delay(multi->slaves[i].pcm, &d);

		if (err < 0)

			return err;

		if (dr < d)

			dr = d;

	}

	*delayp = dr;

	return 0;

}

static snd_pcm_sframes_t snd_pcm_multi_avail_update(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_sframes_t ret = LONG_MAX;

	unsigned int i;

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_sframes_t avail;

		avail = snd_pcm_avail_update(multi->slaves[i].pcm);

		if (avail < 0)

			return avail;

		if (ret > avail)

			ret = avail;

	}

	snd_pcm_multi_hwptr_update(pcm);

	return ret;

}

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

				    snd_htimestamp_t *tstamp)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave = multi->slaves[multi->master_slave].pcm;

	return snd_pcm_htimestamp(slave, avail, tstamp);

}

static int snd_pcm_multi_prepare(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int result = 0, err;

	unsigned int i;

	for (i = 0; i < multi->slaves_count; ++i) {

		/* We call prepare to each slave even if it's linked.

		 * This is to make sure to sync non-mmaped control/status.

		 */

		err = snd_pcm_prepare(multi->slaves[i].pcm);

		if (err < 0)

			result = err;

	}

	multi->hw_ptr = multi->appl_ptr = 0;

	return result;

}

static int snd_pcm_multi_reset(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int result = 0, err;

	unsigned int i;

	for (i = 0; i < multi->slaves_count; ++i) {

		/* Reset each slave, as well as in prepare */

		err = snd_pcm_reset(multi->slaves[i].pcm);

		if (err < 0) 

			result = err;

	}

	multi->hw_ptr = multi->appl_ptr = 0;

	return result;

}

/* when the first slave PCM is linked, it means that the whole multi

 * plugin instance is linked manually to another PCM.  in this case,

 * we need to trigger the master.

 */

static int snd_pcm_multi_start(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int err = 0;

	unsigned int i;

	if (multi->slaves[0].linked)

		return snd_pcm_start(multi->slaves[0].linked);

	for (i = 0; i < multi->slaves_count; ++i) {

		if (multi->slaves[i].linked)

			continue;

		err = snd_pcm_start(multi->slaves[i].pcm);

		if (err < 0)

			return err;

	}

	return err;

}

static int snd_pcm_multi_drop(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int err = 0;

	unsigned int i;

	if (multi->slaves[0].linked)

		return snd_pcm_drop(multi->slaves[0].linked);

	for (i = 0; i < multi->slaves_count; ++i) {

		if (multi->slaves[i].linked)

			continue;

		err = snd_pcm_drop(multi->slaves[i].pcm);

		if (err < 0)

			return err;

	}

	return err;

}

static int snd_pcm_multi_drain(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int err = 0;

	unsigned int i;

	if (multi->slaves[0].linked)

		return snd_pcm_drain(multi->slaves[0].linked);

	for (i = 0; i < multi->slaves_count; ++i) {

		if (multi->slaves[i].linked)

			continue;

		err = snd_pcm_drain(multi->slaves[i].pcm);

		if (err < 0)

			return err;

	}

	return err;

}

static int snd_pcm_multi_pause(snd_pcm_t *pcm, int enable)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int err = 0;

	unsigned int i;

	if (multi->slaves[0].linked)

		return snd_pcm_pause(multi->slaves[0].linked, enable);

	for (i = 0; i < multi->slaves_count; ++i) {

		if (multi->slaves[i].linked)

			continue;

		err = snd_pcm_pause(multi->slaves[i].pcm, enable);

		if (err < 0)

			return err;

	}

	return err;

}

static int snd_pcm_multi_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t *info)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int channel = info->channel;

	snd_pcm_multi_channel_t *c = &multi->channels[channel];

	int err;

	if (c->slave_idx < 0)

		return -ENXIO;

	info->channel = c->slave_channel;

	err = snd_pcm_channel_info(multi->slaves[c->slave_idx].pcm, info);

	info->channel = channel;

	return err;

}

static snd_pcm_sframes_t snd_pcm_multi_rewindable(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	snd_pcm_sframes_t frames = LONG_MAX;

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_sframes_t f = snd_pcm_rewindable(multi->slaves[i].pcm);

		if (f <= 0)

			return f;

		if (f < frames)

			frames = f;

	}

	return frames;

}

static snd_pcm_sframes_t snd_pcm_multi_forwardable(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	snd_pcm_sframes_t frames = LONG_MAX;

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_sframes_t f = snd_pcm_forwardable(multi->slaves[i].pcm);

		if (f <= 0)

			return f;

		if (f < frames)

			frames = f;

	}

	return frames;

}

static snd_pcm_sframes_t snd_pcm_multi_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	snd_pcm_uframes_t pos[multi->slaves_count];

	memset(pos, 0, sizeof(pos));

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_t *slave_i = multi->slaves[i].pcm;

		snd_pcm_sframes_t f = snd_pcm_rewind(slave_i, frames);

		if (f < 0)

			return f;

		pos[i] = f;

		frames = f;

	}

	/* Realign the pointers */

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_t *slave_i = multi->slaves[i].pcm;

		snd_pcm_uframes_t f = pos[i] - frames;

		snd_pcm_sframes_t result;

		if (f > 0) {

			result = INTERNAL(snd_pcm_forward)(slave_i, f);

			if (result < 0)

				return result;

			if ((snd_pcm_uframes_t)result != f)

				return -EIO;

		}

	}

	return frames;

}

static snd_pcm_sframes_t snd_pcm_multi_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	snd_pcm_uframes_t pos[multi->slaves_count];

	memset(pos, 0, sizeof(pos));

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_t *slave_i = multi->slaves[i].pcm;

		snd_pcm_sframes_t f = INTERNAL(snd_pcm_forward)(slave_i, frames);

		if (f < 0)

			return f;

		pos[i] = f;

		frames = f;

	}

	/* Realign the pointers */

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_t *slave_i = multi->slaves[i].pcm;

		snd_pcm_uframes_t f = pos[i] - frames;

		snd_pcm_sframes_t result;

		if (f > 0) {

			result = snd_pcm_rewind(slave_i, f);

			if (result < 0)

				return result;

			if ((snd_pcm_uframes_t)result != f)

				return -EIO;

		}

	}

	return frames;

}

static int snd_pcm_multi_resume(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	int err = 0;

	unsigned int i;

	if (multi->slaves[0].linked)

		return snd_pcm_resume(multi->slaves[0].linked);

	for (i = 0; i < multi->slaves_count; ++i) {

		if (multi->slaves[i].linked)

			continue;

		err = snd_pcm_resume(multi->slaves[i].pcm);

		if (err < 0)

			return err;

	}

	return err;

}

/* if a multi plugin instance is linked as slaves, every slave PCMs

 * including the first one has to be relinked to the given master.

 */

static int snd_pcm_multi_link_slaves(snd_pcm_t *pcm, snd_pcm_t *master)

{ 

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	int err;

	for (i = 0; i < multi->slaves_count; ++i) {

		snd_pcm_unlink(multi->slaves[i].pcm);

		multi->slaves[i].linked = NULL;

		err = snd_pcm_link(master, multi->slaves[i].pcm);

		if (err < 0) {

			reset_links(multi);

			return err;

		}

		multi->slaves[i].linked = master;

	}

	return 0;

}

/* linking to a multi as a master is easy - simply link to the first

 * slave element as its own slaves are already linked.

 */

static int snd_pcm_multi_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)

{

	snd_pcm_multi_t *multi = pcm1->private_data;

	if (multi->slaves[0].pcm->fast_ops->link)

		return multi->slaves[0].pcm->fast_ops->link(multi->slaves[0].pcm, pcm2);

	return -ENOSYS;

}

static int snd_pcm_multi_unlink(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	for (i = 0; i < multi->slaves_count; ++i) {

		if (multi->slaves[i].linked)

			snd_pcm_unlink(multi->slaves[i].linked);

		multi->slaves[0].linked = NULL;

	}

	return 0;

}

static snd_pcm_sframes_t snd_pcm_multi_mmap_commit(snd_pcm_t *pcm,

						   snd_pcm_uframes_t offset,

						   snd_pcm_uframes_t size)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_t *slave;

	unsigned int i;

	snd_pcm_sframes_t result;

	for (i = 0; i < multi->slaves_count; ++i) {

		slave = multi->slaves[i].pcm;

		result = snd_pcm_mmap_commit(slave, offset, size);

		if (result < 0)

			return result;

		if ((snd_pcm_uframes_t)result != size)

			return -EIO;

	}

	multi->appl_ptr += size;

	multi->appl_ptr %= pcm->boundary;

	return size;

}

static int snd_pcm_multi_munmap(snd_pcm_t *pcm)

{

	free(pcm->mmap_channels);

	free(pcm->running_areas);

	pcm->mmap_channels = NULL;

	pcm->running_areas = NULL;

	return 0;

}

static int snd_pcm_multi_mmap(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int c;

	pcm->mmap_channels = calloc(pcm->channels,

				    sizeof(pcm->mmap_channels[0]));

	pcm->running_areas = calloc(pcm->channels,

				    sizeof(pcm->running_areas[0]));

	if (!pcm->mmap_channels || !pcm->running_areas) {

		snd_pcm_multi_munmap(pcm);

		return -ENOMEM;

	}

	/* Copy the slave mmapped buffer data */

	for (c = 0; c < pcm->channels; c++) {

		snd_pcm_multi_channel_t *chan = &multi->channels[c];

		snd_pcm_t *slave;

		if (chan->slave_idx < 0) {

			snd_pcm_multi_munmap(pcm);

			return -ENXIO;

		}

		slave = multi->slaves[chan->slave_idx].pcm;

		pcm->mmap_channels[c] =

			slave->mmap_channels[chan->slave_channel];

		pcm->mmap_channels[c].channel = c;

		pcm->running_areas[c] =

			slave->running_areas[chan->slave_channel];

	}

	return 0;

}

static int snd_pcm_multi_may_wait_for_avail_min(snd_pcm_t *pcm, snd_pcm_uframes_t avail)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	unsigned int i;

	for (i = 0; i < multi->slaves_count; ++i) {

		if (snd_pcm_may_wait_for_avail_min(multi->slaves[i].pcm, avail))

			return 1;

	}

	return 0;

}

static snd_pcm_chmap_query_t **snd_pcm_multi_query_chmaps(snd_pcm_t *pcm)

{

	snd_pcm_multi_t *multi = pcm->private_data;

	snd_pcm_chmap_query_t **slave_maps[multi->slaves_count];

	snd_pcm_chmap_query_t **maps;

	unsigned int i;

	int err = -ENOMEM;

	memset(slave_maps, 0, sizeof(slave_maps));

	maps = calloc(2, sizeof(*maps));

	if (!maps)

		return NULL;

	maps[0] = calloc(multi->channels_count + 2, sizeof(int *));

	if (!maps[0])

		goto error;

	maps[0]->type = SND_CHMAP_TYPE_FIXED;

	maps[0]->map.channels = multi->channels_count;

	for (i = 0; i < multi->slaves_count; i++) {

		slave_maps[i] = snd_pcm_query_chmaps(multi->slaves[i].pcm);

		if (!slave_maps[i])

			goto error;

	}

	for (i = 0; i < multi->channels_count; i++) {

		snd_pcm_multi_channel_t *bind = &multi->channels[i];

		unsigned int slave_channels =

			multi->slaves[bind->slave_idx].channels_count;

		snd_pcm_chmap_query_t **p;

		for (p = slave_maps[bind->slave_idx]; *p; p++) {

			if ((*p)->map.channels == slave_channels) {

				maps[0]->map.pos[i] =

					(*p)->map.pos[bind->slave_channel];

				break;

			}

		}

	}

	err = 0;