/*

 *  A simple PCM loopback utility

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

 *

 *     Author: Jaroslav Kysela <perex@perex.cz>

 *

 *

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

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 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 General Public License for more details.

 *

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

 *   along with this program; 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 <string.h>

#include <sched.h>

#include <errno.h>

#include <getopt.h>

#include <alsa/asoundlib.h>

#include <sys/time.h>

#include <math.h>

#include <syslog.h>

#include <pthread.h>

#include "alsaloop.h"

#define XRUN_PROFILE_UNKNOWN (-10000000)

static int set_rate_shift(struct loopback_handle *lhandle, double pitch);

static int get_rate(struct loopback_handle *lhandle);

#define SYNCTYPE(v) [SYNC_TYPE_##v] = #v

static const char *sync_types[] = {

	SYNCTYPE(NONE),

	SYNCTYPE(SIMPLE),

	SYNCTYPE(CAPTRATESHIFT),

	SYNCTYPE(PLAYRATESHIFT),

	SYNCTYPE(SAMPLERATE),

	SYNCTYPE(AUTO)

};

#define SRCTYPE(v) [SRC_##v] = "SRC_" #v

#ifdef USE_SAMPLERATE

static const char *src_types[] = {

	SRCTYPE(SINC_BEST_QUALITY),

	SRCTYPE(SINC_MEDIUM_QUALITY),

	SRCTYPE(SINC_FASTEST),

	SRCTYPE(ZERO_ORDER_HOLD),

	SRCTYPE(LINEAR)

};

#endif

static pthread_once_t pcm_open_mutex_once = PTHREAD_ONCE_INIT;

static pthread_mutex_t pcm_open_mutex;

static void pcm_open_init_mutex(void)

{

	pthread_mutexattr_t attr;

	pthread_mutexattr_init(&attr);

	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

	pthread_mutex_init(&pcm_open_mutex, &attr);

	pthread_mutexattr_destroy(&attr);

}

static inline void pcm_open_lock(void)

{

	pthread_once(&pcm_open_mutex_once, pcm_open_init_mutex);

	if (workarounds & WORKAROUND_SERIALOPEN)

	        pthread_mutex_lock(&pcm_open_mutex);

}

static inline void pcm_open_unlock(void)

{

	if (workarounds & WORKAROUND_SERIALOPEN)

	        pthread_mutex_unlock(&pcm_open_mutex);

}

static inline snd_pcm_uframes_t get_whole_latency(struct loopback *loop)

{

	return loop->latency;

}

static inline unsigned long long

			frames_to_time(unsigned int rate,

				       snd_pcm_uframes_t frames)

{

	return (frames * 1000000ULL) / rate;

}

static inline snd_pcm_uframes_t time_to_frames(unsigned int rate,

					       unsigned long long time)

{

	return (time * rate) / 1000000ULL;

}

static int setparams_stream(struct loopback_handle *lhandle,

			    snd_pcm_hw_params_t *params)

{

	snd_pcm_t *handle = lhandle->handle;

	int err;

	unsigned int rrate;

	err = snd_pcm_hw_params_any(handle, params);

	if (err < 0) {

		logit(LOG_CRIT, "Broken configuration for %s PCM: no configurations available: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	err = snd_pcm_hw_params_set_rate_resample(handle, params, lhandle->resample);

	if (err < 0) {

		logit(LOG_CRIT, "Resample setup failed for %s (val %i): %s\n", lhandle->id, lhandle->resample, snd_strerror(err));

		return err;

	}

	err = snd_pcm_hw_params_set_access(handle, params, lhandle->access);

	if (err < 0) {

		logit(LOG_CRIT, "Access type not available for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	err = snd_pcm_hw_params_set_format(handle, params, lhandle->format);

	if (err < 0) {

		logit(LOG_CRIT, "Sample format not available for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	err = snd_pcm_hw_params_set_channels(handle, params, lhandle->channels);

	if (err < 0) {

		logit(LOG_CRIT, "Channels count (%i) not available for %s: %s\n", lhandle->channels, lhandle->id, snd_strerror(err));

		return err;

	}

	rrate = lhandle->rate_req;

	err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);

	if (err < 0) {

		logit(LOG_CRIT, "Rate %iHz not available for %s: %s\n", lhandle->rate_req, lhandle->id, snd_strerror(err));

		return err;

	}

	rrate = 0;

	snd_pcm_hw_params_get_rate(params, &rrate, 0);

	lhandle->rate = rrate;

	if (

#ifdef USE_SAMPLERATE

	    !lhandle->loopback->src_enable &&

#endif

	    (int)rrate != lhandle->rate) {

		logit(LOG_CRIT, "Rate does not match (requested %iHz, got %iHz, resample %i)\n", lhandle->rate, rrate, lhandle->resample);

		return -EINVAL;

	}

	lhandle->pitch = (double)lhandle->rate_req / (double)lhandle->rate;

	return 0;

}

static int setparams_bufsize(struct loopback_handle *lhandle,

			     snd_pcm_hw_params_t *params,

			     snd_pcm_hw_params_t *tparams,

			     snd_pcm_uframes_t bufsize)

{

	snd_pcm_t *handle = lhandle->handle;

	int err;

	snd_pcm_uframes_t periodsize;

	snd_pcm_uframes_t buffersize;

	snd_pcm_uframes_t last_bufsize = 0;

	if (lhandle->buffer_size_req > 0) {

		bufsize = lhandle->buffer_size_req;

		last_bufsize = bufsize;

		goto __set_it;

	}

      __again:

	if (lhandle->buffer_size_req > 0) {

		logit(LOG_CRIT, "Unable to set buffer size %li for %s\n", (long)lhandle->buffer_size, lhandle->id);

		return -EIO;

	}

	if (last_bufsize == bufsize)

		bufsize += 4;

	last_bufsize = bufsize;

	if (bufsize > 10*1024*1024) {

		logit(LOG_CRIT, "Buffer size too big\n");

		return -EIO;

	}

      __set_it:

	snd_pcm_hw_params_copy(params, tparams);

	periodsize = bufsize * 8;

	err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &periodsize);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set buffer size %li for %s: %s\n", periodsize, lhandle->id, snd_strerror(err));

		goto __again;

	}

	snd_pcm_hw_params_get_buffer_size(params, &periodsize);

	if (verbose > 6)

		snd_output_printf(lhandle->loopback->output, "%s: buffer_size=%li\n", lhandle->id, periodsize);

	if (lhandle->period_size_req > 0)

		periodsize = lhandle->period_size_req;

	else

		periodsize /= 8;

	err = snd_pcm_hw_params_set_period_size_near(handle, params, &periodsize, 0);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set period size %li for %s: %s\n", periodsize, lhandle->id, snd_strerror(err));

		goto __again;

	}

	snd_pcm_hw_params_get_period_size(params, &periodsize, NULL);

	if (verbose > 6)

		snd_output_printf(lhandle->loopback->output, "%s: period_size=%li\n", lhandle->id, periodsize);

	if (periodsize != bufsize)

		bufsize = periodsize;

	snd_pcm_hw_params_get_buffer_size(params, &buffersize);

	if (periodsize * 2 > buffersize)

		goto __again;

	lhandle->period_size = periodsize;

	lhandle->buffer_size = buffersize;

	return 0;

}

static int setparams_set(struct loopback_handle *lhandle,

			 snd_pcm_hw_params_t *params,

			 snd_pcm_sw_params_t *swparams,

			 snd_pcm_uframes_t bufsize)

{

	snd_pcm_t *handle = lhandle->handle;

	int err;

	snd_pcm_uframes_t val, period_size, buffer_size;

	err = snd_pcm_hw_params(handle, params);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set hw params for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	err = snd_pcm_sw_params_current(handle, swparams);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to determine current swparams for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0x7fffffff);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set start threshold mode for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	snd_pcm_hw_params_get_period_size(params, &period_size, NULL);

	snd_pcm_hw_params_get_buffer_size(params, &buffer_size);

	if (lhandle->nblock) {

		if (lhandle == lhandle->loopback->play) {

			val = buffer_size - (2 * period_size - 4);

		} else {

			val = 4;

		}

		if (verbose > 6)

			snd_output_printf(lhandle->loopback->output, "%s: avail_min1=%li\n", lhandle->id, val);

	} else {

		if (lhandle == lhandle->loopback->play) {

			val = bufsize + bufsize / 2;

			if (val > (buffer_size * 3) / 4)

				val = (buffer_size * 3) / 4;

			val = buffer_size - val;

		} else {

			val = bufsize / 2;

			if (val > buffer_size / 4)

				val = buffer_size / 4;

		}

		if (verbose > 6)

			snd_output_printf(lhandle->loopback->output, "%s: avail_min2=%li\n", lhandle->id, val);

	}

	err = snd_pcm_sw_params_set_avail_min(handle, swparams, val);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set avail min for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	snd_pcm_sw_params_get_avail_min(swparams, &lhandle->avail_min);

	err = snd_pcm_sw_params(handle, swparams);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set sw params for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	return 0;

}

static int increase_playback_avail_min(struct loopback_handle *lhandle)

{

	snd_pcm_t *handle = lhandle->handle;

	snd_pcm_sw_params_t *swparams;

	struct timespec ts;

	int err;

	if (lhandle->avail_min + (lhandle->period_size / 2) > lhandle->buffer_size) {

		/* avoid 100% CPU usage for broken plugins */

		ts.tv_sec = 0;

		ts.tv_nsec = 10000;

		nanosleep(&ts, NULL);

		return 0;

	}

	snd_pcm_sw_params_alloca(&swparams);

	err = snd_pcm_sw_params_current(handle, swparams);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to determine current swparams for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	err = snd_pcm_sw_params_set_avail_min(handle, swparams, lhandle->avail_min + 4);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set avail min for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	snd_pcm_sw_params_get_avail_min(swparams, &lhandle->avail_min);

	if (verbose > 6)

		snd_output_printf(lhandle->loopback->output, "%s: change avail_min=%li\n", lhandle->id, lhandle->avail_min);

	err = snd_pcm_sw_params(handle, swparams);

	if (err < 0) {

		logit(LOG_CRIT, "Unable to set sw params for %s: %s\n", lhandle->id, snd_strerror(err));

		return err;

	}

	return 0;

}

static int setparams(struct loopback *loop, snd_pcm_uframes_t bufsize)

{

	int err;

	snd_pcm_hw_params_t *pt_params, *ct_params;	/* templates with rate, format and channels */

	snd_pcm_hw_params_t *p_params, *c_params;

	snd_pcm_sw_params_t *p_swparams, *c_swparams;

	snd_pcm_hw_params_alloca(&p_params);

	snd_pcm_hw_params_alloca(&c_params);

	snd_pcm_hw_params_alloca(&pt_params);

	snd_pcm_hw_params_alloca(&ct_params);

	snd_pcm_sw_params_alloca(&p_swparams);

	snd_pcm_sw_params_alloca(&c_swparams);

	if ((err = setparams_stream(loop->play, pt_params)) < 0) {

		logit(LOG_CRIT, "Unable to set parameters for %s stream: %s\n", loop->play->id, snd_strerror(err));

		return err;

	}

	if ((err = setparams_stream(loop->capt, ct_params)) < 0) {

		logit(LOG_CRIT, "Unable to set parameters for %s stream: %s\n", loop->capt->id, snd_strerror(err));

		return err;

	}

	if ((err = setparams_bufsize(loop->play, p_params, pt_params, bufsize / loop->play->pitch)) < 0) {

		logit(LOG_CRIT, "Unable to set buffer parameters for %s stream: %s\n", loop->play->id, snd_strerror(err));

		return err;

	}

	if ((err = setparams_bufsize(loop->capt, c_params, ct_params, bufsize / loop->capt->pitch)) < 0) {

		logit(LOG_CRIT, "Unable to set buffer parameters for %s stream: %s\n", loop->capt->id, snd_strerror(err));

		return err;

	}

	if ((err = setparams_set(loop->play, p_params, p_swparams, bufsize / loop->play->pitch)) < 0) {

		logit(LOG_CRIT, "Unable to set sw parameters for %s stream: %s\n", loop->play->id, snd_strerror(err));

		return err;

	}

	if ((err = setparams_set(loop->capt, c_params, c_swparams, bufsize / loop->capt->pitch)) < 0) {

		logit(LOG_CRIT, "Unable to set sw parameters for %s stream: %s\n", loop->capt->id, snd_strerror(err));

		return err;

	}

#if 0

	if (!loop->linked)

		if (snd_pcm_link(loop->capt->handle, loop->play->handle) >= 0)

			loop->linked = 1;

#endif

	if ((err = snd_pcm_prepare(loop->play->handle)) < 0) {

		logit(LOG_CRIT, "Prepare %s error: %s\n", loop->play->id, snd_strerror(err));

		return err;

	}

	if (!loop->linked && (err = snd_pcm_prepare(loop->capt->handle)) < 0) {

		logit(LOG_CRIT, "Prepare %s error: %s\n", loop->capt->id, snd_strerror(err));

		return err;

	}

	if (verbose) {

		snd_pcm_dump(loop->play->handle, loop->output);

		snd_pcm_dump(loop->capt->handle, loop->output);

	}

	return 0;

}

static void showlatency(snd_output_t *out, size_t latency, unsigned int rate,

			char *prefix)

{

	double d;

	d = (double)latency / (double)rate;

	snd_output_printf(out, "%s %li frames, %.3fus, %.6fms (%.4fHz)\n", prefix, (long)latency, d * 1000000, d * 1000, (double)1 / d);

}

static long timediff(snd_timestamp_t t1, snd_timestamp_t t2)

{

	signed long l;

	t1.tv_sec -= t2.tv_sec;

	if (t1.tv_usec < t2.tv_usec) {

		l = ((t1.tv_usec + 1000000) - t2.tv_usec) % 1000000;

		t1.tv_sec--;

	} else {

		l = t1.tv_usec - t2.tv_usec;

	}

	return (t1.tv_sec * 1000000) + l;

}

static int getcurtimestamp(snd_timestamp_t *ts)

{

	struct timeval tv;

	gettimeofday(&tv, NULL);

	ts->tv_sec = tv.tv_sec;

	ts->tv_usec = tv.tv_usec;

	return 0;

}

static void xrun_profile0(struct loopback *loop)

{

	snd_pcm_sframes_t pdelay, cdelay;

	if (snd_pcm_delay(loop->play->handle, &pdelay) >= 0 &&

	    snd_pcm_delay(loop->capt->handle, &cdelay) >= 0) {

		getcurtimestamp(&loop->xrun_last_update);

		loop->xrun_last_pdelay = pdelay;

		loop->xrun_last_cdelay = cdelay;

		loop->xrun_buf_pcount = loop->play->buf_count;

		loop->xrun_buf_ccount = loop->capt->buf_count;

#ifdef USE_SAMPLERATE

		loop->xrun_out_frames = loop->src_out_frames;

#endif

	}

}

static inline void xrun_profile(struct loopback *loop)

{

	if (loop->xrun)

		xrun_profile0(loop);

}

static void xrun_stats0(struct loopback *loop)

{

	snd_timestamp_t t;

	double expected, last, wake, check, queued = -1, proc, missing = -1;

	double maxbuf, pfilled, cfilled, cqueued = -1, avail_min;

	double sincejob;

	expected = ((double)loop->latency /

				(double)loop->play->rate_req) * 1000;

	getcurtimestamp(&t);

	last = (double)timediff(t, loop->xrun_last_update) / 1000;

	wake = (double)timediff(t, loop->xrun_last_wake) / 1000;

	check = (double)timediff(t, loop->xrun_last_check) / 1000;

	sincejob = (double)timediff(t, loop->tstamp_start) / 1000;

	if (loop->xrun_last_pdelay != XRUN_PROFILE_UNKNOWN)

		queued = ((double)loop->xrun_last_pdelay /

				(double)loop->play->rate) * 1000;

	if (loop->xrun_last_cdelay != XRUN_PROFILE_UNKNOWN)

		cqueued = ((double)loop->xrun_last_cdelay /

				(double)loop->capt->rate) * 1000;

	maxbuf = ((double)loop->play->buffer_size /

				(double)loop->play->rate) * 1000;

	proc = (double)loop->xrun_max_proctime / 1000;

	pfilled = ((double)(loop->xrun_buf_pcount + loop->xrun_out_frames) /

				(double)loop->play->rate) * 1000;

	cfilled = ((double)loop->xrun_buf_ccount /

				(double)loop->capt->rate) * 1000;

	avail_min = (((double)loop->play->buffer_size - 

				(double)loop->play->avail_min ) / 

				(double)loop->play->rate) * 1000;

	avail_min = expected - avail_min;

	if (queued >= 0)

		missing = last - queued;

	if (missing >= 0 && loop->xrun_max_missing < missing)

		loop->xrun_max_missing = missing;

	loop->xrun_max_proctime = 0;

	getcurtimestamp(&t);

	logit(LOG_INFO, "  last write before %.4fms, queued %.4fms/%.4fms -> missing %.4fms\n", last, queued, cqueued, missing);

	logit(LOG_INFO, "  expected %.4fms, processing %.4fms, max missing %.4fms\n", expected, proc, loop->xrun_max_missing);

	logit(LOG_INFO, "  last wake %.4fms, last check %.4fms, avail_min %.4fms\n", wake, check, avail_min);

	logit(LOG_INFO, "  max buf %.4fms, pfilled %.4fms, cfilled %.4fms\n", maxbuf, pfilled, cfilled);

	logit(LOG_INFO, "  job started before %.4fms\n", sincejob);

}

static inline void xrun_stats(struct loopback *loop)

{

	if (loop->xrun)

		xrun_stats0(loop);

}

static inline snd_pcm_uframes_t buf_avail(struct loopback_handle *lhandle)

{

	return lhandle->buf_size - lhandle->buf_count;

}

static void buf_remove(struct loopback *loop, snd_pcm_uframes_t count)

{

	/* remove samples from the capture buffer */

	if (count <= 0)

		return;

	if (loop->play->buf == loop->capt->buf) {

		if (count < loop->capt->buf_count)

			loop->capt->buf_count -= count;

		else

			loop->capt->buf_count = 0;

	}

}

#if 0

static void buf_add_copy(struct loopback *loop)

{

	struct loopback_handle *capt = loop->capt;

	struct loopback_handle *play = loop->play;

	snd_pcm_uframes_t count, count1, cpos, ppos;

	count = capt->buf_count;

	cpos = capt->buf_pos - count;

	if (cpos > capt->buf_size)

		cpos += capt->buf_size;

	ppos = (play->buf_pos + play->buf_count) % play->buf_size;

	while (count > 0) {

		count1 = count;

		if (count1 + cpos > capt->buf_size)

			count1 = capt->buf_size - cpos;

		if (count1 > buf_avail(play))

			count1 = buf_avail(play);

		if (count1 + ppos > play->buf_size)

			count1 = play->buf_size - ppos;

		if (count1 == 0)

			break;

		memcpy(play->buf + ppos * play->frame_size,

		       capt->buf + cpos * capt->frame_size,

		       count1 * capt->frame_size);

		play->buf_count += count1;

		capt->buf_count -= count1;

		ppos += count1;

		ppos %= play->buf_size;

		cpos += count1;

		cpos %= capt->buf_size;

		count -= count1;

	}

}

#endif

#ifdef USE_SAMPLERATE

static void buf_add_src(struct loopback *loop)

{

	struct loopback_handle *capt = loop->capt;

	struct loopback_handle *play = loop->play;

	float *old_data_out;

	snd_pcm_uframes_t count, pos, count1, pos1;

	count = capt->buf_count;

	pos = 0;

	pos1 = capt->buf_pos - count;

	if (pos1 > capt->buf_size)

		pos1 += capt->buf_size;

	while (count > 0) {

		count1 = count;

		if (count1 + pos1 > capt->buf_size)

			count1 = capt->buf_size - pos1;

		if (capt->format == SND_PCM_FORMAT_S32)

			src_int_to_float_array((int *)(capt->buf +

						pos1 * capt->frame_size),

					 (void *)loop->src_data.data_in +

					   pos * capt->channels,

					 count1 * capt->channels);

		else

			src_short_to_float_array((short *)(capt->buf +

						pos1 * capt->frame_size),

					 (void *)loop->src_data.data_in +

					   pos * capt->channels,

					 count1 * capt->channels);

		count -= count1;

		pos += count1;

		pos1 += count1;

		pos1 %= capt->buf_size;

	}

	loop->src_data.input_frames = pos;

	loop->src_data.output_frames = play->buf_size -

						loop->src_out_frames;

	loop->src_data.end_of_input = 0;

	old_data_out = loop->src_data.data_out;

	loop->src_data.data_out = old_data_out + loop->src_out_frames;

	src_process(loop->src_state, &loop->src_data);

	loop->src_data.data_out = old_data_out;

	capt->buf_count -= loop->src_data.input_frames_used;

	count = loop->src_data.output_frames_gen +

		loop->src_out_frames;

	pos = 0;

	pos1 = (play->buf_pos + play->buf_count) % play->buf_size;

	while (count > 0) {

		count1 = count;

		if (count1 + pos1 > play->buf_size)

			count1 = play->buf_size - pos1;

		if (count1 > buf_avail(play))

			count1 = buf_avail(play);

		if (count1 == 0)

			break;

		if (capt->format == SND_PCM_FORMAT_S32)

			src_float_to_int_array(loop->src_data.data_out +

					   pos * play->channels,

					 (int *)(play->buf +

					   pos1 * play->frame_size),

					 count1 * play->channels);

		else

			src_float_to_short_array(loop->src_data.data_out +

					   pos * play->channels,

					 (short *)(play->buf +

					   pos1 * play->frame_size),

					 count1 * play->channels);

		play->buf_count += count1;

		count -= count1;

		pos += count1;

		pos1 += count1;

		pos1 %= play->buf_size;

	}

#if 0

	printf("src: pos = %li, gen = %li, out = %li, count = %li\n",

		(long)pos, (long)loop->src_data.output_frames_gen,

		(long)loop->src_out_frames, play->buf_count);

#endif

	loop->src_out_frames = (loop->src_data.output_frames_gen +

					loop->src_out_frames) - pos;

	if (loop->src_out_frames > 0) {

		memmove(loop->src_data.data_out,

			loop->src_data.data_out + pos * play->channels,

			loop->src_out_frames * play->channels * sizeof(float));

	}

}

#else

static void buf_add_src(struct loopback *loop)

{

}

#endif

static void buf_add(struct loopback *loop, snd_pcm_uframes_t count)

{

	/* copy samples from capture to playback buffer */

	if (count <= 0)

		return;

	if (loop->play->buf == loop->capt->buf) {

		loop->play->buf_count += count;

	} else {

		buf_add_src(loop);

	}

}

static int xrun(struct loopback_handle *lhandle)

{

	int err;

	if (lhandle == lhandle->loopback->play) {

		logit(LOG_DEBUG, "underrun for %s\n", lhandle->id);

		xrun_stats(lhandle->loopback);

		if ((err = snd_pcm_prepare(lhandle->handle)) < 0)

			return err;

		lhandle->xrun_pending = 1;

	} else {

		logit(LOG_DEBUG, "overrun for %s\n", lhandle->id);

		xrun_stats(lhandle->loopback);

		if ((err = snd_pcm_prepare(lhandle->handle)) < 0)

			return err;

		lhandle->xrun_pending = 1;

	}

	return 0;

}

static int suspend(struct loopback_handle *lhandle)

{

	int err;

	while ((err = snd_pcm_resume(lhandle->handle)) == -EAGAIN)

		usleep(1);

	if (err < 0)

		return xrun(lhandle);

	return 0;

}

static int readit(struct loopback_handle *lhandle)

{

	snd_pcm_sframes_t r, res = 0;

	snd_pcm_sframes_t avail;

	int err;

	avail = snd_pcm_avail_update(lhandle->handle);

	if (avail == -EPIPE) {

		return xrun(lhandle);

	} else if (avail == -ESTRPIPE) {

		if ((err = suspend(lhandle)) < 0)

			return err;

	}

	if (avail > buf_avail(lhandle)) {

		lhandle->buf_over += avail - buf_avail(lhandle);

		avail = buf_avail(lhandle);

	} else if (avail == 0) {

		if (snd_pcm_state(lhandle->handle) == SND_PCM_STATE_DRAINING) {

			lhandle->loopback->reinit = 1;

			return 0;

		}

	}

	while (avail > 0) {

		r = buf_avail(lhandle);

		if (r + lhandle->buf_pos > lhandle->buf_size)

			r = lhandle->buf_size - lhandle->buf_pos;

		if (r > avail)

			r = avail;

		r = snd_pcm_readi(lhandle->handle,

				  lhandle->buf +

				  lhandle->buf_pos *

				  lhandle->frame_size, r);

		if (r == 0)

			return res;

		if (r < 0) {

			if (r == -EPIPE) {

				err = xrun(lhandle);

				return res > 0 ? res : err;

			} else if (r == -ESTRPIPE) {

				if ((err = suspend(lhandle)) < 0)

					return res > 0 ? res : err;

				r = 0;

			} else {

				return res > 0 ? res : r;

			}

		}

#ifdef FILE_CWRITE

		if (lhandle->loopback->cfile)

			fwrite(lhandle->buf + lhandle->buf_pos * lhandle->frame_size,

			       r, lhandle->frame_size, lhandle->loopback->cfile);

#endif

		res += r;

		if (lhandle->max < res)

			lhandle->max = res;

		lhandle->counter += r;

		lhandle->buf_count += r;

		lhandle->buf_pos += r;

		lhandle->buf_pos %= lhandle->buf_size;

		avail -= r;

	}

	return res;

}

static int writeit(struct loopback_handle *lhandle)

{

	snd_pcm_sframes_t avail;

	snd_pcm_sframes_t r, res = 0;

	int err;

      __again:

	avail = snd_pcm_avail_update(lhandle->handle);

	if (avail == -EPIPE) {

		if ((err = xrun(lhandle)) < 0)

			return err;

		return res;

	} else if (avail == -ESTRPIPE) {

		if ((err = suspend(lhandle)) < 0)

			return err;

		goto __again;

	}

	while (avail > 0 && lhandle->buf_count > 0) {

		r = lhandle->buf_count;

		if (r + lhandle->buf_pos > lhandle->buf_size)

			r = lhandle->buf_size - lhandle->buf_pos;

		if (r > avail)

			r = avail;

		r = snd_pcm_writei(lhandle->handle,

				   lhandle->buf +

				   lhandle->buf_pos *

				   lhandle->frame_size, r);

		if (r <= 0) {

			if (r == -EPIPE) {

				if ((err = xrun(lhandle)) < 0)

					return err;

				return res;

			} else if (r == -ESTRPIPE) {

			}

			return res > 0 ? res : r;

		}

#ifdef FILE_PWRITE

		if (lhandle->loopback->pfile)

			fwrite(lhandle->buf + lhandle->buf_pos * lhandle->frame_size,

			       r, lhandle->frame_size, lhandle->loopback->pfile);

#endif

		res += r;

		lhandle->counter += r;

		lhandle->buf_count -= r;

		lhandle->buf_pos += r;

		lhandle->buf_pos %= lhandle->buf_size;

		xrun_profile(lhandle->loopback);

		if (lhandle->loopback->stop_pending) {

			lhandle->loopback->stop_count += r;

			if (lhandle->loopback->stop_count * lhandle->pitch >

			    lhandle->loopback->latency * 3) {

				lhandle->loopback->stop_pending = 0;

				lhandle->loopback->reinit = 1;

				break;

			}

		}

	}

	return res;

}

static snd_pcm_sframes_t remove_samples(struct loopback *loop,

					int capture_preferred,

					snd_pcm_sframes_t count)

{

	struct loopback_handle *play = loop->play;

	struct loopback_handle *capt = loop->capt;

	if (loop->play->buf == loop->capt->buf) {

		if (count > loop->play->buf_count)

			count = loop->play->buf_count;

		if (count > loop->capt->buf_count)

			count = loop->capt->buf_count;

		capt->buf_count -= count;

		play->buf_pos += count;

		play->buf_pos %= play->buf_size;

		play->buf_count -= count;

		return count;

	}

	if (capture_preferred) {

		if (count > capt->buf_count)

			count = capt->buf_count;

		capt->buf_count -= count;

	} else {

		if (count > play->buf_count)

			count = play->buf_count;

		play->buf_count -= count;

	}

	return count;

}

static int xrun_sync(struct loopback *loop)

{

	struct loopback_handle *play = loop->play;

	struct loopback_handle *capt = loop->capt;

	snd_pcm_uframes_t fill = get_whole_latency(loop);

	snd_pcm_sframes_t pdelay, cdelay, delay1, pdelay1, cdelay1, diff;

	int err;

      __again:

	if (verbose > 5)

		snd_output_printf(loop->output, "%s: xrun sync %i %i\n", loop->id, capt->xrun_pending, play->xrun_pending);

	if (capt->xrun_pending) {

	      __pagain:

		capt->xrun_pending = 0;

		if ((err = snd_pcm_prepare(capt->handle)) < 0) {

			logit(LOG_CRIT, "%s prepare failed: %s\n", capt->id, snd_strerror(err));

			return err;

		}

		if ((err = snd_pcm_start(capt->handle)) < 0) {

			logit(LOG_CRIT, "%s start failed: %s\n", capt->id, snd_strerror(err));

			return err;

		}

	} else {

		diff = readit(capt);

		buf_add(loop, diff);

		if (capt->xrun_pending)

			goto __pagain;

	}

	/* skip additional playback samples */

	if ((err = snd_pcm_delay(capt->handle, &cdelay)) < 0) {

		if (err == -EPIPE) {

			capt->xrun_pending = 1;

			goto __again;

		}

		if (err == -ESTRPIPE) {

			err = suspend(capt);

			if (err < 0)

				return err;

			goto __again;

		}

		logit(LOG_CRIT, "%s capture delay failed: %s\n", capt->id, snd_strerror(err));

		return err;

	}

	if ((err = snd_pcm_delay(play->handle, &pdelay)) < 0) {

		if (err == -EPIPE) {

			pdelay = 0;

			play->xrun_pending = 1;

		} else if (err == -ESTRPIPE) {

			err = suspend(play);

			if (err < 0)

				return err;

			goto __again;

		} else {

			logit(LOG_CRIT, "%s playback delay failed: %s\n", play->id, snd_strerror(err));