diff --git a/Makefile.am b/Makefile.am

index c484d4da..ff4c963a 100644

--- a/Makefile.am

+++ b/Makefile.am

@@ -16,7 +16,7 @@ SUBDIRS += alsalisp

 endif

 endif

 SUBDIRS += test utils

-EXTRA_DIST=ChangeLog INSTALL TODO NOTES configure gitcompile libtool \

+EXTRA_DIST=README.md ChangeLog INSTALL TODO NOTES configure gitcompile libtool \

 	   depcomp version MEMORY-LEAK m4/attributes.m4

 AUTOMAKE_OPTIONS=foreign

diff --git a/include/pcm.h b/include/pcm.h

index 5b078231..e300b951 100644

--- a/include/pcm.h

+++ b/include/pcm.h

@@ -350,6 +350,20 @@ typedef enum _snd_pcm_tstamp_type {

 	SND_PCM_TSTAMP_TYPE_LAST = SND_PCM_TSTAMP_TYPE_MONOTONIC_RAW,

 } snd_pcm_tstamp_type_t;

+typedef enum _snd_pcm_audio_tstamp_type {

+	/**

+	 * first definition for backwards compatibility only,

+	 * maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else

+	 */

+	SND_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0,

+	SND_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1,           /**< DMA time, reported as per hw_ptr */

+	SND_PCM_AUDIO_TSTAMP_TYPE_LINK = 2,	           /**< link time reported by sample or wallclock counter, reset on startup */

+	SND_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3,	   /**< link time reported by sample or wallclock counter, not reset on startup */

+	SND_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4,    /**< link time estimated indirectly */

+	SND_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, /**< link time synchronized with system time */

+	SND_PCM_AUDIO_TSTAMP_TYPE_LAST = SND_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED

+} snd_pcm_audio_tstamp_type_t;

+

 typedef struct _snd_pcm_audio_tstamp_config {

 	/* 5 of max 16 bits used */

 	unsigned int type_requested:4;

diff --git a/include/sound/uapi/asoc.h b/include/sound/uapi/asoc.h

index 4efb4ec4..f32c5697 100644

--- a/include/sound/uapi/asoc.h

+++ b/include/sound/uapi/asoc.h

@@ -169,16 +169,22 @@

 #define SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP            (1 << 3)

 /* DAI topology BCLK parameter

- * For the backwards capability, by default codec is bclk master

+ * For the backwards capability, by default codec is bclk provider

  */

-#define SND_SOC_TPLG_BCLK_CM         0 /* codec is bclk master */

-#define SND_SOC_TPLG_BCLK_CS         1 /* codec is bclk slave */

+#define SND_SOC_TPLG_BCLK_CP         0 /* codec is bclk provider */

+#define SND_SOC_TPLG_BCLK_CC         1 /* codec is bclk consumer */

+/* keep previous definitions for compatibility */

+#define SND_SOC_TPLG_BCLK_CM         SND_SOC_TPLG_BCLK_CP

+#define SND_SOC_TPLG_BCLK_CS         SND_SOC_TPLG_BCLK_CC

 /* DAI topology FSYNC parameter

- * For the backwards capability, by default codec is fsync master

+ * For the backwards capability, by default codec is fsync provider

  */

-#define SND_SOC_TPLG_FSYNC_CM         0 /* codec is fsync master */

-#define SND_SOC_TPLG_FSYNC_CS         1 /* codec is fsync slave */

+#define SND_SOC_TPLG_FSYNC_CP         0 /* codec is fsync provider */

+#define SND_SOC_TPLG_FSYNC_CC         1 /* codec is fsync consumer */

+/* keep previous definitions for compatibility */

+#define SND_SOC_TPLG_FSYNC_CM         SND_SOC_TPLG_FSYNC_CP

+#define SND_SOC_TPLG_FSYNC_CS         SND_SOC_TPLG_FSYNC_CC

 /*

  * Block Header.

@@ -335,8 +341,8 @@ struct snd_soc_tplg_hw_config {

 	__u8 clock_gated;	/* SND_SOC_TPLG_DAI_CLK_GATE_ value */

 	__u8 invert_bclk;	/* 1 for inverted BCLK, 0 for normal */

 	__u8 invert_fsync;	/* 1 for inverted frame clock, 0 for normal */

-	__u8 bclk_master;	/* SND_SOC_TPLG_BCLK_ value */

-	__u8 fsync_master;	/* SND_SOC_TPLG_FSYNC_ value */

+	__u8 bclk_provider;	/* SND_SOC_TPLG_BCLK_ value */

+	__u8 fsync_provider;	/* SND_SOC_TPLG_FSYNC_ value */

 	__u8 mclk_direction;    /* SND_SOC_TPLG_MCLK_ value */

 	__le16 reserved;	/* for 32bit alignment */

 	__le32 mclk_rate;	/* MCLK or SYSCLK freqency in Hz */

diff --git a/include/topology.h b/include/topology.h

index 1f52e66e..d1feee4d 100644

--- a/include/topology.h

+++ b/include/topology.h

@@ -658,8 +658,8 @@ extern "C" {

  *

  *	id "1"				# used for binding to the config

  *	format "I2S"			# physical audio format.

- *	bclk   "master"			# Platform is master of bit clock

- *	fsync  "slave"			# Platform is slave of fsync

+ *	bclk   "codec_provider"		# Codec provides the bit clock

+ *	fsync  "codec_consumer"		# Codec follows the fsync

  * }

  * 

  *

@@ -1028,8 +1028,8 @@ struct snd_tplg_hw_config_template {

 	unsigned char clock_gated;      /* SND_SOC_TPLG_DAI_CLK_GATE_ value */

 	unsigned char  invert_bclk;     /* 1 for inverted BCLK, 0 for normal */

 	unsigned char  invert_fsync;    /* 1 for inverted frame clock, 0 for normal */

-	unsigned char  bclk_master;     /* SND_SOC_TPLG_BCLK_ value */

-	unsigned char  fsync_master;    /* SND_SOC_TPLG_FSYNC_ value */

+	unsigned char  bclk_provider;   /* SND_SOC_TPLG_BCLK_ value */

+	unsigned char  fsync_provider;  /* SND_SOC_TPLG_FSYNC_ value */

 	unsigned char  mclk_direction;  /* SND_SOC_TPLG_MCLK_ value */

 	unsigned short reserved;        /* for 32bit alignment */

 	unsigned int mclk_rate;	        /* MCLK or SYSCLK freqency in Hz */

diff --git a/src/conf.c b/src/conf.c

index 7df2b4e7..3c943db2 100644

--- a/src/conf.c

+++ b/src/conf.c

@@ -887,7 +887,7 @@ static inline int get_hexachar(input_t *input)

 	if (c >= '0' && c <= '9') num |= (c - '0') << 0;

 	else if (c >= 'a' && c <= 'f') num |= (c - 'a') << 0;

 	else if (c >= 'A' && c <= 'F') num |= (c - 'A') << 0;

-	return c;

+	return num;

 }

 static int get_quotedchar(input_t *input)

@@ -1970,11 +1970,14 @@ int _snd_config_load_with_include(snd_config_t *config, snd_input_t *in,

 		SNDERR("%s:%d:%d:%s", fd->name ? fd->name : "_toplevel_", fd->line, fd->column, str);

 		goto _end;

 	}

-	if (get_char(&input) != LOCAL_UNEXPECTED_EOF) {

+	err = get_char(&input);

+	fd = input.current;

+	if (err != LOCAL_UNEXPECTED_EOF) {

 		SNDERR("%s:%d:%d:Unexpected }", fd->name ? fd->name : "", fd->line, fd->column);

 		err = -EINVAL;

 		goto _end;

 	}

+	err = 0;

  _end:

 	while (fd->next) {

 		fd_next = fd->next;

diff --git a/src/conf/cards/USB-Audio.conf b/src/conf/cards/USB-Audio.conf

index 9b64af3c..b1b74b02 100644

--- a/src/conf/cards/USB-Audio.conf

+++ b/src/conf/cards/USB-Audio.conf

@@ -39,6 +39,7 @@ USB-Audio.pcm.iec958_device {

 	# "NoiseBlaster 3000" 42

 	"USB Sound Blaster HD" 1

 	"Xonar U7" 1

+	"Xonar U7 MKII" 1

 	"ASUS XONAR U5" 1

 	"XONAR U5" 1

 	"XONAR SOUND CARD" 1

diff --git a/src/confmisc.c b/src/confmisc.c

index eb8218c1..3ce95c7a 100644

--- a/src/confmisc.c

+++ b/src/confmisc.c

@@ -419,7 +419,6 @@ int snd_func_concat(snd_config_t **dst, snd_config_t *root, snd_config_t *src,

 				tmp = realloc(res, len + len1 + 1);

 				if (tmp == NULL) {

 					free(ptr);

-					free(res);

 					err = -ENOMEM;

 					goto __error;

 				}

@@ -440,8 +439,8 @@ int snd_func_concat(snd_config_t **dst, snd_config_t *root, snd_config_t *src,

 	err = snd_config_get_id(src, &id;;

 	if (err >= 0)

 		err = snd_config_imake_string(dst, id, res);

-	free(res);

       __error:

+	free(res);

 	return err;

 }

 #ifndef DOC_HIDDEN

diff --git a/src/dlmisc.c b/src/dlmisc.c

index c9517c55..1dd91356 100644

--- a/src/dlmisc.c

+++ b/src/dlmisc.c

@@ -42,13 +42,11 @@

 #ifndef PIC

 struct snd_dlsym_link *snd_dlsym_start = NULL;

 #endif

-#ifdef DL_ORIGIN_AVAILABLE

 static int snd_plugin_dir_set = 0;

 static char *snd_plugin_dir = NULL;

 #endif

-#endif

-#if defined(DL_ORIGIN_AVAILABLE) && defined(HAVE_LIBPTHREAD)

+#ifdef HAVE_LIBPTHREAD

 static pthread_mutex_t snd_dlpath_mutex = PTHREAD_MUTEX_INITIALIZER;

 static inline void snd_dlpath_lock(void)

@@ -442,12 +440,10 @@ void snd_dlobj_cache_cleanup(void)

 		free(c);

 	}

 	snd_dlobj_unlock();

-#ifdef DL_ORIGIN_AVAILABLE

 	snd_dlpath_lock();

 	snd_plugin_dir_set = 0;

 	free(snd_plugin_dir);

 	snd_plugin_dir = NULL;

 	snd_dlpath_unlock();

-#endif

 }

 #endif

diff --git a/src/pcm/pcm_ioplug.c b/src/pcm/pcm_ioplug.c

index a437ca32..e141b1f9 100644

--- a/src/pcm/pcm_ioplug.c

+++ b/src/pcm/pcm_ioplug.c

@@ -107,16 +107,35 @@ static int snd_pcm_ioplug_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t *i

 	return snd_pcm_channel_info_shm(pcm, info, -1);

 }

+static int snd_pcm_ioplug_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)

+{

+	ioplug_priv_t *io = pcm->private_data;

+

+	if (io->data->version >= 0x010001 &&

+	    io->data->callback->delay)

+		return io->data->callback->delay(io->data, delayp);

+	else {

+		snd_pcm_ioplug_hw_ptr_update(pcm);

+		*delayp = snd_pcm_mmap_delay(pcm);

+	}

+	return 0;

+}

+

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

 {

 	ioplug_priv_t *io = pcm->private_data;

+	snd_pcm_sframes_t sd;

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

 	snd_pcm_ioplug_hw_ptr_update(pcm);

 	status->state = io->data->state;

 	status->trigger_tstamp = io->trigger_tstamp;

+	gettimestamp(&status->tstamp, pcm->tstamp_type);

 	status->avail = snd_pcm_mmap_avail(pcm);

 	status->avail_max = io->avail_max;

+	if (snd_pcm_ioplug_delay(pcm, &sd) < 0)

+		sd = snd_pcm_mmap_delay(pcm);

+	status->delay = sd;

 	return 0;

 }

@@ -132,20 +151,6 @@ static int snd_pcm_ioplug_hwsync(snd_pcm_t *pcm)

 	return 0;

 }

-static int snd_pcm_ioplug_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)

-{

-	ioplug_priv_t *io = pcm->private_data;

-

-	if (io->data->version >= 0x010001 &&

-	    io->data->callback->delay)

-		return io->data->callback->delay(io->data, delayp);

-	else {

-		snd_pcm_ioplug_hw_ptr_update(pcm);

-		*delayp = snd_pcm_mmap_hw_avail(pcm);

-	}

-	return 0;

-}

-

 static int snd_pcm_ioplug_reset(snd_pcm_t *pcm)

 {

 	ioplug_priv_t *io = pcm->private_data;

diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h

index fe77e50d..bec5a408 100644

--- a/src/pcm/pcm_local.h

+++ b/src/pcm/pcm_local.h

@@ -444,7 +444,7 @@ static inline int __snd_pcm_start(snd_pcm_t *pcm)

 static inline snd_pcm_state_t __snd_pcm_state(snd_pcm_t *pcm)

 {

 	if (!pcm->fast_ops->state)

-		return -ENOSYS;

+		return SND_PCM_STATE_OPEN;

 	return pcm->fast_ops->state(pcm->fast_op_arg);

 }

diff --git a/src/pcm/pcm_mmap.c b/src/pcm/pcm_mmap.c

index 9600c383..9cbaae05 100644

--- a/src/pcm/pcm_mmap.c

+++ b/src/pcm/pcm_mmap.c

@@ -183,7 +183,7 @@ snd_pcm_sframes_t snd_pcm_mmap_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_ufram

  * \brief Read interleaved frames from a PCM using direct buffer (mmap)

  * \param pcm PCM handle

  * \param buffer frames containing buffer

- * \param size frames to be written

+ * \param size frames to be read

  * \return a positive number of frames actually read otherwise a

  * negative error code

  * \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)

diff --git a/src/pcm/pcm_multi.c b/src/pcm/pcm_multi.c

index 53c414d5..5fa09b9b 100644

--- a/src/pcm/pcm_multi.c

+++ b/src/pcm/pcm_multi.c

@@ -1323,7 +1323,6 @@ int _snd_pcm_multi_open(snd_pcm_t **pcmp, const char *name,

 		err = -ENOMEM;

 		goto _free;

 	}

-	idx = 0;

 	for (idx = 0; idx < channels_count; ++idx)

 		channels_sidx[idx] = -1;

 	idx = 0;

diff --git a/src/pcm/pcm_plugin.c b/src/pcm/pcm_plugin.c

index 5739cfc2..7ed6f25a 100644

--- a/src/pcm/pcm_plugin.c

+++ b/src/pcm/pcm_plugin.c

@@ -142,12 +142,6 @@ static int snd_pcm_plugin_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)

 	int err = snd_pcm_delay(plugin->gen.slave, &sd);

 	if (err < 0)

 		return err;

-        if (pcm->stream == SND_PCM_STREAM_CAPTURE &&

-	    pcm->access != SND_PCM_ACCESS_RW_INTERLEAVED &&

-	    pcm->access != SND_PCM_ACCESS_RW_NONINTERLEAVED) {

-                sd += snd_pcm_mmap_capture_avail(pcm);

-        }        

-

 	*delayp = sd;

 	return 0;

 }

@@ -460,101 +454,121 @@ snd_pcm_plugin_mmap_commit(snd_pcm_t *pcm,

 	return xfer > 0 ? xfer : err;

 }

-static snd_pcm_sframes_t snd_pcm_plugin_avail_update(snd_pcm_t *pcm)

+static snd_pcm_sframes_t

+snd_pcm_plugin_sync_hw_ptr_capture(snd_pcm_t *pcm,

+				   snd_pcm_sframes_t slave_size)

 {

 	snd_pcm_plugin_t *plugin = pcm->private_data;

 	snd_pcm_t *slave = plugin->gen.slave;

-	snd_pcm_sframes_t slave_size;

+	const snd_pcm_channel_area_t *areas;

+	snd_pcm_uframes_t xfer, hw_offset, size;

 	int err;

-	slave_size = snd_pcm_avail_update(slave);

+	xfer = snd_pcm_mmap_capture_avail(pcm);

+	size = pcm->buffer_size - xfer;

+	areas = snd_pcm_mmap_areas(pcm);

+	hw_offset = snd_pcm_mmap_hw_offset(pcm);

+	while (size > 0 && slave_size > 0) {

+		snd_pcm_uframes_t frames = size;

+		snd_pcm_uframes_t cont = pcm->buffer_size - hw_offset;

+		const snd_pcm_channel_area_t *slave_areas;

+		snd_pcm_uframes_t slave_offset;

+		snd_pcm_uframes_t slave_frames = ULONG_MAX;

+		snd_pcm_sframes_t result;

+		/* As mentioned in the ALSA API (see pcm/pcm.c:942):

+		 * The function #snd_pcm_avail_update()

+		 * have to be called before any mmap begin+commit operation.

+		 * Otherwise the snd_pcm_areas_copy will not called a second time.

+		 * But this is needed, if the ring buffer wrap is reached and

+		 * there is more data available.

+		 */

+		slave_size = snd_pcm_avail_update(slave);

+		result = snd_pcm_mmap_begin(slave, &slave_areas, &slave_offset, &slave_frames);

+		if (result < 0) {

+			err = result;

+			goto error;

+		}

+		if (frames > cont)

+			frames = cont;

+		frames = (plugin->read)(pcm, areas, hw_offset, frames,

+					slave_areas, slave_offset, &slave_frames);

+		result = snd_pcm_mmap_commit(slave, slave_offset, slave_frames);

+		if (result > 0 && (snd_pcm_uframes_t)result != slave_frames) {

+			snd_pcm_sframes_t res;

+			res = plugin->undo_read(slave, areas, hw_offset, frames, slave_frames - result);

+			if (res < 0) {

+				err = res;

+				goto error;

+			}

+			frames -= res;

+		}

+		if (result <= 0) {

+			err = result;

+			goto error;

+		}

+		snd_pcm_mmap_hw_forward(pcm, frames);

+		if (frames == cont)

+			hw_offset = 0;

+		else

+			hw_offset += frames;

+		size -= frames;

+		slave_size -= slave_frames;

+		xfer += frames;

+	}

+	return (snd_pcm_sframes_t)xfer;

+error:

+	return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;

+}

+

+static snd_pcm_sframes_t snd_pcm_plugin_sync_hw_ptr(snd_pcm_t *pcm,

+						    snd_pcm_uframes_t slave_hw_ptr,

+						    snd_pcm_sframes_t slave_size)

+{

 	if (pcm->stream == SND_PCM_STREAM_CAPTURE &&

 	    pcm->access != SND_PCM_ACCESS_RW_INTERLEAVED &&

 	    pcm->access != SND_PCM_ACCESS_RW_NONINTERLEAVED)

-		goto _capture;

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

+		return snd_pcm_plugin_sync_hw_ptr_capture(pcm, slave_size);

+        *pcm->hw.ptr = slave_hw_ptr;

         return slave_size;

- _capture:

- 	{

-		const snd_pcm_channel_area_t *areas;

-		snd_pcm_uframes_t xfer, hw_offset, size;

-		

-		xfer = snd_pcm_mmap_capture_avail(pcm);

-		size = pcm->buffer_size - xfer;

-		areas = snd_pcm_mmap_areas(pcm);

-		hw_offset = snd_pcm_mmap_hw_offset(pcm);

-		while (size > 0 && slave_size > 0) {

-			snd_pcm_uframes_t frames = size;

-			snd_pcm_uframes_t cont = pcm->buffer_size - hw_offset;

-			const snd_pcm_channel_area_t *slave_areas;

-			snd_pcm_uframes_t slave_offset;

-			snd_pcm_uframes_t slave_frames = ULONG_MAX;

-			snd_pcm_sframes_t result;

-			/* As mentioned in the ALSA API (see pcm/pcm.c:942):

-			 * The function #snd_pcm_avail_update()

-			 * have to be called before any mmap begin+commit operation.

-			 * Otherwise the snd_pcm_areas_copy will not called a second time.

-			 * But this is needed, if the ring buffer wrap is reached and

-			 * there is more data available.

-			 */

-			slave_size = snd_pcm_avail_update(slave);

-			result = snd_pcm_mmap_begin(slave, &slave_areas, &slave_offset, &slave_frames);

-			if (result < 0) {

-				err = result;

-				goto error;

-			}

-			if (frames > cont)

-				frames = cont;

-			frames = (plugin->read)(pcm, areas, hw_offset, frames,

-					      slave_areas, slave_offset, &slave_frames);

-			result = snd_pcm_mmap_commit(slave, slave_offset, slave_frames);

-			if (result > 0 && (snd_pcm_uframes_t)result != slave_frames) {

-				snd_pcm_sframes_t res;

-				

-				res = plugin->undo_read(slave, areas, hw_offset, frames, slave_frames - result);

-				if (res < 0) {

-					err = res;

-					goto error;

-				}

-				frames -= res;

-			}

-			if (result <= 0) {

-				err = result;

-				goto error;

-			}

-			snd_pcm_mmap_hw_forward(pcm, frames);

-			if (frames == cont)

-				hw_offset = 0;

-			else

-				hw_offset += frames;

-			size -= frames;

-			slave_size -= slave_frames;

-			xfer += frames;

-		}

-		return (snd_pcm_sframes_t)xfer;

+}

-	error:

-		return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;

-	}

+static snd_pcm_sframes_t snd_pcm_plugin_avail_update(snd_pcm_t *pcm)

+{

+	snd_pcm_plugin_t *plugin = pcm->private_data;

+	snd_pcm_t *slave = plugin->gen.slave;

+	snd_pcm_sframes_t slave_size;

+

+	slave_size = snd_pcm_avail_update(slave);

+	return snd_pcm_plugin_sync_hw_ptr(pcm, *slave->hw.ptr, slave_size);

 }

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

 {

 	snd_pcm_plugin_t *plugin = pcm->private_data;

-	snd_pcm_sframes_t err, avail;

-

-	/* sync with the latest hw and appl ptrs */

-	avail = snd_pcm_plugin_avail_update(pcm);

-	if (avail < 0)

-		return avail;

+	snd_pcm_sframes_t err, diff;

 	err = snd_pcm_status(plugin->gen.slave, status);

 	if (err < 0)

 		return err;

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

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

-	status->avail = avail;

-	status->delay = snd_pcm_mmap_delay(pcm);

+	snd_pcm_plugin_sync_hw_ptr(pcm, status->hw_ptr, status->avail);

+	/*

+	 * For capture stream, the situation is more complicated, because

+	 * snd_pcm_plugin_avail_update() commits the data to the slave pcm.

+	 * It means that the slave appl_ptr is updated. Calculate diff and

+	 * update the delay and avail.

+	 *

+	 * This resolves the data inconsistency for immediate calls:

+	 *    snd_pcm_avail_update()

+	 *    snd_pcm_status()

+	 */

+	if (pcm->stream == SND_PCM_STREAM_CAPTURE) {

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

+		diff = pcm_frame_diff(status->appl_ptr, *pcm->appl.ptr, pcm->boundary);

+		status->avail += diff;

+		status->delay += diff;

+	} else {

+		assert(status->appl_ptr == *pcm->appl.ptr);

+	}

 	return 0;

 }

diff --git a/src/pcm/pcm_rate.c b/src/pcm/pcm_rate.c

index 5bf7dbb9..770aafea 100644

--- a/src/pcm/pcm_rate.c

+++ b/src/pcm/pcm_rate.c

@@ -561,17 +561,16 @@ snd_pcm_rate_read_areas1(snd_pcm_t *pcm,

 static inline void snd_pcm_rate_sync_hwptr0(snd_pcm_t *pcm, snd_pcm_uframes_t slave_hw_ptr)

 {

-	snd_pcm_rate_t *rate = pcm->private_data;

-

-	snd_pcm_sframes_t slave_hw_ptr_diff = slave_hw_ptr - rate->last_slave_hw_ptr;

+	snd_pcm_rate_t *rate;

+	snd_pcm_sframes_t slave_hw_ptr_diff;

 	snd_pcm_sframes_t last_slave_hw_ptr_frac;

 	if (pcm->stream != SND_PCM_STREAM_PLAYBACK)

 		return;

-	if (slave_hw_ptr_diff < 0)

-		slave_hw_ptr_diff += rate->gen.slave->boundary; /* slave boundary wraparound */

-	else if (slave_hw_ptr_diff == 0)

+	rate = pcm->private_data;

+	slave_hw_ptr_diff = pcm_frame_diff(slave_hw_ptr, rate->last_slave_hw_ptr, rate->gen.slave->boundary);

+	if (slave_hw_ptr_diff == 0)

 		return;

 	last_slave_hw_ptr_frac = rate->last_slave_hw_ptr % rate->gen.slave->period_size;

 	/* While handling fraction part fo slave period, rounded value will be

@@ -612,11 +611,7 @@ static snd_pcm_uframes_t snd_pcm_rate_playback_internal_delay(snd_pcm_t *pcm)

 {

 	snd_pcm_rate_t *rate = pcm->private_data;

-	if (rate->appl_ptr < rate->last_commit_ptr) {

-		return rate->appl_ptr - rate->last_commit_ptr + pcm->boundary;

-	} else {

-		return rate->appl_ptr - rate->last_commit_ptr;

-	}

+	return pcm_frame_diff(rate->appl_ptr, rate->last_commit_ptr, pcm->boundary);

 }

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

@@ -637,7 +632,7 @@ static int snd_pcm_rate_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)

 				+ snd_pcm_rate_playback_internal_delay(pcm);

 	} else {

 		*delayp = rate->ops.output_frames(rate->obj, slave_delay)

-				+ snd_pcm_mmap_capture_hw_avail(pcm);

+				+ snd_pcm_mmap_capture_delay(pcm);

 	}

 	return 0;

 }

@@ -746,7 +741,6 @@ static int snd_pcm_rate_commit_area(snd_pcm_t *pcm, snd_pcm_rate_t *rate,

 		if (result < 0)

 			return result;

 	      __partial:

-		xfer = 0;

 		cont = slave_frames;

 		if (cont > slave_size)

 			cont = slave_size;

@@ -846,7 +840,6 @@ static int snd_pcm_rate_grab_next_period(snd_pcm_t *pcm, snd_pcm_uframes_t hw_of

 		if (result < 0)

 			return result;

 	      __partial:

-		xfer = 0;

 		cont = slave_frames;

 		if (cont > rate->gen.slave->period_size)

 			cont = rate->gen.slave->period_size;

@@ -928,10 +921,7 @@ static int snd_pcm_rate_sync_playback_area(snd_pcm_t *pcm, snd_pcm_uframes_t app

 	if (slave_size < 0)

 		return slave_size;

-	if (appl_ptr < rate->last_commit_ptr)

-		xfer = appl_ptr - rate->last_commit_ptr + pcm->boundary;

-	else

-		xfer = appl_ptr - rate->last_commit_ptr;

+	xfer = pcm_frame_diff(appl_ptr, rate->last_commit_ptr, pcm->boundary);

 	while (xfer >= pcm->period_size &&

 	       (snd_pcm_uframes_t)slave_size >= rate->gen.slave->period_size) {

 		err = snd_pcm_rate_commit_next_period(pcm, rate->last_commit_ptr % pcm->buffer_size);

@@ -966,29 +956,18 @@ static snd_pcm_sframes_t snd_pcm_rate_mmap_commit(snd_pcm_t *pcm,

 	return size;

 }

-static snd_pcm_sframes_t snd_pcm_rate_avail_update(snd_pcm_t *pcm)

+static snd_pcm_sframes_t snd_pcm_rate_avail_update_capture(snd_pcm_t *pcm,

+							   snd_pcm_sframes_t slave_size)

 {

 	snd_pcm_rate_t *rate = pcm->private_data;

 	snd_pcm_t *slave = rate->gen.slave;

-	snd_pcm_sframes_t slave_size;

-

-	slave_size = snd_pcm_avail_update(slave);

-	if (slave_size < 0)

-		return slave_size;

-

-	if (pcm->stream == SND_PCM_STREAM_CAPTURE)

-		goto _capture;

-	snd_pcm_rate_sync_hwptr(pcm);

-	snd_pcm_rate_sync_playback_area(pcm, rate->appl_ptr);

-	return snd_pcm_mmap_avail(pcm);

- _capture: {

 	snd_pcm_uframes_t xfer, hw_offset, size;

 	xfer = snd_pcm_mmap_capture_avail(pcm);

 	size = pcm->buffer_size - xfer;

 	hw_offset = snd_pcm_mmap_hw_offset(pcm);

 	while (size >= pcm->period_size &&

-	       (snd_pcm_uframes_t)slave_size >= rate->gen.slave->period_size) {

+	       (snd_pcm_uframes_t)slave_size >= slave->period_size) {

 		int err = snd_pcm_rate_grab_next_period(pcm, hw_offset);

 		if (err < 0)

 			return err;

@@ -996,13 +975,29 @@ static snd_pcm_sframes_t snd_pcm_rate_avail_update(snd_pcm_t *pcm)

 			return (snd_pcm_sframes_t)xfer;

 		xfer += pcm->period_size;

 		size -= pcm->period_size;

-		slave_size -= rate->gen.slave->period_size;

+		slave_size -= slave->period_size;

 		hw_offset += pcm->period_size;

 		hw_offset %= pcm->buffer_size;

 		snd_pcm_mmap_hw_forward(pcm, pcm->period_size);

 	}

 	return (snd_pcm_sframes_t)xfer;

- }

+}

+

+static snd_pcm_sframes_t snd_pcm_rate_avail_update(snd_pcm_t *pcm)

+{

+	snd_pcm_rate_t *rate = pcm->private_data;

+	snd_pcm_sframes_t slave_size;

+

+	slave_size = snd_pcm_avail_update(rate->gen.slave);

+	if (slave_size < 0)

+		return slave_size;

+

+	if (pcm->stream == SND_PCM_STREAM_CAPTURE)

+		return snd_pcm_rate_avail_update_capture(pcm, slave_size);

+

+	snd_pcm_rate_sync_hwptr(pcm);

+	snd_pcm_rate_sync_playback_area(pcm, rate->appl_ptr);

+	return snd_pcm_mmap_avail(pcm);

 }

 static int snd_pcm_rate_htimestamp(snd_pcm_t *pcm,

@@ -1060,9 +1055,7 @@ static int snd_pcm_rate_drain(snd_pcm_t *pcm)

 		sw_params.avail_min = 1;

 		snd_pcm_sw_params(rate->gen.slave, &sw_params);

-		size = rate->appl_ptr - rate->last_commit_ptr;

-		if (size > pcm->boundary)

-			size -= pcm->boundary;

+		size = pcm_frame_diff(rate->appl_ptr, rate->last_commit_ptr, pcm->boundary);

 		ofs = rate->last_commit_ptr % pcm->buffer_size;

 		while (size > 0) {

 			snd_pcm_uframes_t psize, spsize;

@@ -1164,12 +1157,8 @@ static int snd_pcm_rate_status(snd_pcm_t *pcm, snd_pcm_status_t * status)

 		status->avail = snd_pcm_mmap_playback_avail(pcm);

 		status->avail_max = rate->ops.input_frames(rate->obj, status->avail_max);

 	} else {

-		/* FIXME: Maybe possible to somthing similar to

-		 * snd_pcm_rate_playback_internal_delay()

-		 * for the capture case.

-		 */

 		status->delay = rate->ops.output_frames(rate->obj, status->delay)

-					+ snd_pcm_mmap_capture_hw_avail(pcm);

+					+ snd_pcm_mmap_capture_delay(pcm);

 		status->avail = snd_pcm_mmap_capture_avail(pcm);

 		status->avail_max = rate->ops.output_frames(rate->obj, status->avail_max);

 	}

diff --git a/src/rawmidi/rawmidi_virt.c b/src/rawmidi/rawmidi_virt.c

index 2c4c27f5..884b8ff8 100644

--- a/src/rawmidi/rawmidi_virt.c

+++ b/src/rawmidi/rawmidi_virt.c

@@ -315,7 +315,7 @@ int snd_rawmidi_virtual_open(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,

 			     int merge, int mode)

 {

 	int err;

-	snd_rawmidi_t *rmidi;

+	snd_rawmidi_t *rmidi = NULL;

 	snd_rawmidi_virtual_t *virt = NULL;

 	struct pollfd pfd;

@@ -392,6 +392,7 @@ int snd_rawmidi_virtual_open(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,

 		free(*inputp);

 	if (outputp)

 		free(*outputp);

+	free(rmidi);

 	return err;

 }

diff --git a/src/timer/timer_query_hw.c b/src/timer/timer_query_hw.c

index dad228c8..d8bac6e7 100644

--- a/src/timer/timer_query_hw.c

+++ b/src/timer/timer_query_hw.c

@@ -104,7 +104,7 @@ int snd_timer_query_hw_open(snd_timer_query_t **handle, const char *name, int mo

 		close(fd);

 		return -SND_ERROR_INCOMPATIBLE_VERSION;

 	}

-	tmr = (snd_timer_query_t *) calloc(1, sizeof(snd_timer_t));

+	tmr = (snd_timer_query_t *) calloc(1, sizeof(snd_timer_query_t));

 	if (tmr == NULL) {

 		close(fd);

 		return -ENOMEM;

diff --git a/src/topology/dapm.c b/src/topology/dapm.c