Some cleaning renames. Prepared API for new plugins

include/aserver.h

@@ -40,8 +40,8 @@ typedef struct {
 		snd_pcm_channel_info_t channel_info;
 		snd_pcm_channel_params_t channel_params;
 		snd_pcm_channel_setup_t channel_setup;
-		off_t frame_data;
+		off_t appl_ptr;
-		int frame_io;
+		int hw_ptr;
 		int link;
 		snd_xfer_t read;
 		snd_xfer_t write;

include/pcm.h

@@ -125,8 +125,8 @@ int snd_pcm_drain(snd_pcm_t *handle);
 int snd_pcm_flush(snd_pcm_t *handle);
 int snd_pcm_pause(snd_pcm_t *handle, int enable);
 int snd_pcm_state(snd_pcm_t *handle);
-ssize_t snd_pcm_frame_io(snd_pcm_t *handle, int update);
+ssize_t snd_pcm_hw_ptr(snd_pcm_t *handle, int update);
-ssize_t snd_pcm_frame_data(snd_pcm_t *handle, off_t offset);
+ssize_t snd_pcm_appl_ptr(snd_pcm_t *handle, off_t offset);
 ssize_t snd_pcm_write(snd_pcm_t *handle, const void *buffer, size_t size);
 ssize_t snd_pcm_read(snd_pcm_t *handle, void *buffer, size_t size);
 ssize_t snd_pcm_writev(snd_pcm_t *handle, const struct iovec *vector, unsigned long  count);
@@ -142,8 +142,8 @@ int snd_pcm_channels_mask(snd_pcm_t *handle, bitset_t *client_vmask);
 int snd_pcm_mmap(snd_pcm_t *handle, snd_pcm_mmap_status_t **status, snd_pcm_mmap_control_t **control, void **buffer);
 int snd_pcm_munmap(snd_pcm_t *handle);
 int snd_pcm_mmap_state(snd_pcm_t *handle);
-ssize_t snd_pcm_mmap_frame_io(snd_pcm_t *handle);
+ssize_t snd_pcm_mmap_hw_ptr(snd_pcm_t *handle);
-ssize_t snd_pcm_mmap_frame_data(snd_pcm_t *handle, off_t offset);
+ssize_t snd_pcm_mmap_appl_ptr(snd_pcm_t *handle, off_t offset);
 int snd_pcm_mmap_status(snd_pcm_t *handle, snd_pcm_mmap_status_t **status);
 int snd_pcm_mmap_control(snd_pcm_t *handle, snd_pcm_mmap_control_t **control);
 int snd_pcm_mmap_data(snd_pcm_t *handle, void **buffer);
@@ -155,9 +155,9 @@ ssize_t snd_pcm_mmap_write(snd_pcm_t *handle, const void *buffer, size_t size);
 ssize_t snd_pcm_mmap_read(snd_pcm_t *handle, void *buffer, size_t size);
 ssize_t snd_pcm_mmap_writev(snd_pcm_t *handle, const struct iovec *vector, unsigned long  count);
 ssize_t snd_pcm_mmap_readv(snd_pcm_t *handle, const struct iovec *vector, unsigned long count);
-int snd_pcm_mmap_frames_avail(snd_pcm_t *handle, ssize_t *frames);
+int snd_pcm_mmap_avail(snd_pcm_t *handle, ssize_t *frames);
-ssize_t snd_pcm_mmap_frames_xfer(snd_pcm_t *handle, size_t frames);
+ssize_t snd_pcm_mmap_xfer(snd_pcm_t *handle, size_t frames);
-ssize_t snd_pcm_mmap_frames_offset(snd_pcm_t *handle);
+ssize_t snd_pcm_mmap_offset(snd_pcm_t *handle);
 ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *handle, snd_pcm_channel_area_t *channels, size_t frames);
 ssize_t snd_pcm_mmap_write_frames(snd_pcm_t *handle, const void *buffer, size_t frames);
 ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *handle, snd_pcm_channel_area_t *channels, size_t frames);

src/aserver/aserver.c

@@ -368,8 +368,8 @@ int pcm_shm_cmd(client_t *client)
 	case SND_PCM_IOCTL_STATUS:
 		ctrl->result = snd_pcm_status(pcm, &ctrl->u.status);
 		break;
-	case SND_PCM_IOCTL_FRAME_IO:
+	case SND_PCM_IOCTL_HW_PTR:
-		ctrl->result = snd_pcm_frame_io(pcm, ctrl->u.frame_io);
+		ctrl->result = snd_pcm_hw_ptr(pcm, ctrl->u.hw_ptr);
 		break;
 	case SND_PCM_IOCTL_PREPARE:
 		ctrl->result = snd_pcm_prepare(pcm);
@@ -475,8 +475,8 @@ int pcm_shm_cmd(client_t *client)
 		ctrl->result = snd_pcm_readv(pcm, vector, ctrl->u.readv.count);
 		break;
 	}
-	case SND_PCM_IOCTL_FRAME_DATA:
+	case SND_PCM_IOCTL_APPL_PTR:
-		ctrl->result = snd_pcm_frame_data(pcm, ctrl->u.frame_data);
+		ctrl->result = snd_pcm_appl_ptr(pcm, ctrl->u.appl_ptr);
 		break;
 	case SND_PCM_IOCTL_LINK:
 	{

src/pcm/pcm.c

@@ -152,13 +152,13 @@ int snd_pcm_state(snd_pcm_t *handle)
 	return handle->fast_ops->state(handle->fast_op_arg);
 }
 
-ssize_t snd_pcm_frame_io(snd_pcm_t *handle, int update)
+ssize_t snd_pcm_hw_ptr(snd_pcm_t *handle, int update)
 {
 	assert(handle);
 	assert(handle->valid_setup);
 	if (handle->mmap_status && !update)
-		return handle->mmap_status->frame_io;
+		return handle->mmap_status->hw_ptr;
-	return handle->fast_ops->frame_io(handle->fast_op_arg, update);
+	return handle->fast_ops->hw_ptr(handle->fast_op_arg, update);
 }
 
 int snd_pcm_prepare(snd_pcm_t *handle)
@@ -192,15 +192,15 @@ int snd_pcm_pause(snd_pcm_t *handle, int enable)
 }
 
 
-ssize_t snd_pcm_frame_data(snd_pcm_t *handle, off_t offset)
+ssize_t snd_pcm_appl_ptr(snd_pcm_t *handle, off_t offset)
 {
 	assert(handle);
 	assert(handle->valid_setup);
 	if (handle->mmap_control) {
 		if (offset == 0)
-			return handle->mmap_control->frame_data;
+			return handle->mmap_control->appl_ptr;
 	}
-	return handle->fast_ops->frame_data(handle->fast_op_arg, offset);
+	return handle->fast_ops->appl_ptr(handle->fast_op_arg, offset);
 }
 
 ssize_t snd_pcm_write(snd_pcm_t *handle, const void *buffer, size_t size)
@@ -208,7 +208,7 @@ ssize_t snd_pcm_write(snd_pcm_t *handle, const void *buffer, size_t size)
 	assert(handle);
 	assert(size == 0 || buffer);
 	assert(handle->valid_setup);
-	assert(size % handle->setup.frames_align == 0);
+	assert(size % handle->setup.align == 0);
 	return handle->fast_ops->write(handle->fast_op_arg, 0, buffer, size);
 }
 
@@ -227,7 +227,7 @@ ssize_t snd_pcm_read(snd_pcm_t *handle, void *buffer, size_t size)
 	assert(handle);
 	assert(size == 0 || buffer);
 	assert(handle->valid_setup);
-	assert(size % handle->setup.frames_align == 0);
+	assert(size % handle->setup.align == 0);
 	return handle->fast_ops->read(handle->fast_op_arg, 0, buffer, size);
 }
 
@@ -398,13 +398,13 @@ int snd_pcm_dump_setup(snd_pcm_t *handle, FILE *fp)
 	fprintf(fp, "buffer_size: %ld\n", (long)setup->buffer_size);
 	fprintf(fp, "frag_size: %ld\n", (long)setup->frag_size);
 	fprintf(fp, "frags: %ld\n", (long)setup->frags);
-	fprintf(fp, "frame_boundary: %ld\n", (long)setup->frame_boundary);
+	fprintf(fp, "boundary: %ld\n", (long)setup->boundary);
 	fprintf(fp, "msbits_per_sample: %d\n", setup->msbits_per_sample);
-	fprintf(fp, "frames_min: %ld\n", (long)setup->frames_min);
+	fprintf(fp, "avail_min: %ld\n", (long)setup->avail_min);
-	fprintf(fp, "frames_align: %ld\n", (long)setup->frames_align);
+	fprintf(fp, "align: %ld\n", (long)setup->align);
-	fprintf(fp, "frames_xrun_max: %ld\n", (long)setup->frames_xrun_max);
+	fprintf(fp, "xrun_max: %ld\n", (long)setup->xrun_max);
 	fprintf(fp, "fill_mode: %s\n", assoc(setup->fill_mode, fills));
-	fprintf(fp, "frames_fill_max: %ld\n", (long)setup->frames_fill_max);
+	fprintf(fp, "fill_max: %ld\n", (long)setup->fill_max);
 	return 0;
 }
 

src/pcm/pcm_client.c

@@ -298,13 +298,13 @@ static int snd_pcm_client_shm_state(snd_pcm_t *pcm)
 	return status.state;
 }
 
-static ssize_t snd_pcm_client_shm_frame_io(snd_pcm_t *pcm, int update)
+static ssize_t snd_pcm_client_shm_hw_ptr(snd_pcm_t *pcm, int update)
 {
 	snd_pcm_client_t *client = pcm->private;
 	snd_pcm_client_shm_t *ctrl = client->u.shm.ctrl;
 	int err;
-	ctrl->cmd = SND_PCM_IOCTL_FRAME_IO;
+	ctrl->cmd = SND_PCM_IOCTL_HW_PTR;
-	ctrl->u.frame_io = update;
+	ctrl->u.hw_ptr = update;
 	err = snd_pcm_client_shm_action(pcm);
 	if (err < 0)
 		return err;
@@ -372,13 +372,13 @@ static int snd_pcm_client_shm_pause(snd_pcm_t *pcm, int enable)
 	return ctrl->result;
 }
 
-static ssize_t snd_pcm_client_shm_frame_data(snd_pcm_t *pcm, off_t offset)
+static ssize_t snd_pcm_client_shm_appl_ptr(snd_pcm_t *pcm, off_t offset)
 {
 	snd_pcm_client_t *client = pcm->private;
 	snd_pcm_client_shm_t *ctrl = client->u.shm.ctrl;
 	int err;
-	ctrl->cmd = SND_PCM_IOCTL_FRAME_DATA;
+	ctrl->cmd = SND_PCM_IOCTL_APPL_PTR;
-	ctrl->u.frame_data = offset;
+	ctrl->u.appl_ptr = offset;
 	err = snd_pcm_client_shm_action(pcm);
 	if (err < 0)
 		return err;
@@ -654,14 +654,14 @@ struct snd_pcm_fast_ops snd_pcm_client_fast_ops = {
 	channel_params: snd_pcm_client_shm_channel_params,
 	channel_setup: snd_pcm_client_shm_channel_setup,
 	status: snd_pcm_client_shm_status,
-	frame_io: snd_pcm_client_shm_frame_io,
+	hw_ptr: snd_pcm_client_shm_hw_ptr,
 	state: snd_pcm_client_shm_state,
 	prepare: snd_pcm_client_shm_prepare,
 	go: snd_pcm_client_shm_go,
 	drain: snd_pcm_client_shm_drain,
 	flush: snd_pcm_client_shm_flush,
 	pause: snd_pcm_client_shm_pause,
-	frame_data: snd_pcm_client_shm_frame_data,
+	appl_ptr: snd_pcm_client_shm_appl_ptr,
 	write: snd_pcm_client_shm_write,
 	writev: snd_pcm_client_shm_writev,
 	read: snd_pcm_client_shm_read,

src/pcm/pcm_hw.c

@@ -150,11 +150,11 @@ static int snd_pcm_hw_state(snd_pcm_t *pcm)
 	return status.state;
 }
 
-static ssize_t snd_pcm_hw_frame_io(snd_pcm_t *pcm, int update ATTRIBUTE_UNUSED)
+static ssize_t snd_pcm_hw_hw_ptr(snd_pcm_t *pcm, int update ATTRIBUTE_UNUSED)
 {
 	snd_pcm_hw_t *hw = pcm->private;
 	int fd = hw->fd;
-	ssize_t pos = ioctl(fd, SND_PCM_IOCTL_FRAME_IO);
+	ssize_t pos = ioctl(fd, SND_PCM_IOCTL_HW_PTR);
 	if (pos < 0)
 		return -errno;
 	return pos;
@@ -205,14 +205,14 @@ static int snd_pcm_hw_pause(snd_pcm_t *pcm, int enable)
 	return 0;
 }
 
-static ssize_t snd_pcm_hw_frame_data(snd_pcm_t *pcm, off_t offset)
+static ssize_t snd_pcm_hw_appl_ptr(snd_pcm_t *pcm, off_t offset)
 {
 	ssize_t result;
 	snd_pcm_hw_t *hw = pcm->private;
 	int fd = hw->fd;
 	if (pcm->mmap_status && pcm->mmap_control)
-		return snd_pcm_mmap_frame_data(pcm, offset);
+		return snd_pcm_mmap_appl_ptr(pcm, offset);
-	result = ioctl(fd, SND_PCM_IOCTL_FRAME_DATA, offset);
+	result = ioctl(fd, SND_PCM_IOCTL_APPL_PTR, offset);
 	if (result < 0)
 		return -errno;
 	return result;
@@ -392,14 +392,14 @@ struct snd_pcm_fast_ops snd_pcm_hw_fast_ops = {
 	channel_params: snd_pcm_hw_channel_params,
 	channel_setup: snd_pcm_hw_channel_setup,
 	status: snd_pcm_hw_status,
-	frame_io: snd_pcm_hw_frame_io,
+	hw_ptr: snd_pcm_hw_hw_ptr,
 	state: snd_pcm_hw_state,
 	prepare: snd_pcm_hw_prepare,
 	go: snd_pcm_hw_go,
 	drain: snd_pcm_hw_drain,
 	flush: snd_pcm_hw_flush,
 	pause: snd_pcm_hw_pause,
-	frame_data: snd_pcm_hw_frame_data,
+	appl_ptr: snd_pcm_hw_appl_ptr,
 	write: snd_pcm_hw_write,
 	writev: snd_pcm_hw_writev,
 	read: snd_pcm_hw_read,

src/pcm/pcm_local.h

@@ -43,8 +43,8 @@ struct snd_pcm_fast_ops {
 	int (*flush)(snd_pcm_t *pcm);
 	int (*pause)(snd_pcm_t *pcm, int enable);
 	int (*state)(snd_pcm_t *pcm);
-	ssize_t (*frame_io)(snd_pcm_t *pcm, int update);
+	ssize_t (*hw_ptr)(snd_pcm_t *pcm, int update);
-	ssize_t (*frame_data)(snd_pcm_t *pcm, off_t offset);
+	ssize_t (*appl_ptr)(snd_pcm_t *pcm, off_t offset);
 	ssize_t (*write)(snd_pcm_t *pcm, snd_timestamp_t *tstamp, const void *buffer, size_t size);
 	ssize_t (*writev)(snd_pcm_t *pcm, snd_timestamp_t *tstamp, const struct iovec *vector, unsigned long count);
 	ssize_t (*read)(snd_pcm_t *pcm, snd_timestamp_t *tstamp, void *buffer, size_t size);
@@ -131,22 +131,22 @@ int conv_index(int src_format, int dst_format);
 #define pdprintf( args... ) { ; }
 #endif
 
-static inline size_t snd_pcm_mmap_playback_frames_avail(snd_pcm_t *str)
+static inline size_t snd_pcm_mmap_playback_avail(snd_pcm_t *str)
 {
-	ssize_t frames_avail;
+	ssize_t avail;
-	frames_avail = str->mmap_status->frame_io + str->setup.buffer_size - str->mmap_control->frame_data;
+	avail = str->mmap_status->hw_ptr + str->setup.buffer_size - str->mmap_control->appl_ptr;
-	if (frames_avail < 0)
+	if (avail < 0)
-		frames_avail += str->setup.frame_boundary;
+		avail += str->setup.boundary;
-	return frames_avail;
+	return avail;
 }
 
-static inline size_t snd_pcm_mmap_capture_frames_avail(snd_pcm_t *str)
+static inline size_t snd_pcm_mmap_capture_avail(snd_pcm_t *str)
 {
-	ssize_t frames_avail;
+	ssize_t avail;
-	frames_avail = str->mmap_status->frame_io - str->mmap_control->frame_data;
+	avail = str->mmap_status->hw_ptr - str->mmap_control->appl_ptr;
-	if (frames_avail < 0)
+	if (avail < 0)
-		frames_avail += str->setup.frame_boundary;
+		avail += str->setup.boundary;
-	return frames_avail;
+	return avail;
 }
 
 #define snd_pcm_plug_stream(plug) ((plug)->handle->stream)

src/pcm/pcm_mmap.c

@@ -26,14 +26,14 @@
 #include <sys/uio.h>
 #include "pcm_local.h"
 
-int snd_pcm_frames_avail(snd_pcm_t *handle, ssize_t *frames)
+int snd_pcm_avail(snd_pcm_t *handle, ssize_t *frames)
 {
         assert(handle);
 	assert(handle->mmap_status && handle->mmap_control);
 	if (handle->stream == SND_PCM_STREAM_PLAYBACK)
-		*frames = snd_pcm_mmap_playback_frames_avail(handle);
+		*frames = snd_pcm_mmap_playback_avail(handle);
 	else
-		*frames = snd_pcm_mmap_capture_frames_avail(handle);
+		*frames = snd_pcm_mmap_capture_avail(handle);
 	return 0;
 }
 
@@ -41,7 +41,7 @@ static int snd_pcm_mmap_playback_ready(snd_pcm_t *handle)
 {
 	if (handle->mmap_status->state == SND_PCM_STATE_XRUN)
 		return -EPIPE;
-	return snd_pcm_mmap_playback_frames_avail(handle) >= handle->setup.frames_min;
+	return snd_pcm_mmap_playback_avail(handle) >= handle->setup.avail_min;
 }
 
 static int snd_pcm_mmap_capture_ready(snd_pcm_t *handle)
@@ -52,7 +52,7 @@ static int snd_pcm_mmap_capture_ready(snd_pcm_t *handle)
 		if (handle->setup.xrun_mode == SND_PCM_XRUN_DRAIN)
 			return -EPIPE;
 	}
-	if (snd_pcm_mmap_capture_frames_avail(handle) >= handle->setup.frames_min)
+	if (snd_pcm_mmap_capture_avail(handle) >= handle->setup.avail_min)
 		return 1;
 	return ret;
 }
@@ -69,47 +69,47 @@ int snd_pcm_mmap_ready(snd_pcm_t *handle)
 	}
 }
 
-static size_t snd_pcm_mmap_playback_frames_xfer(snd_pcm_t *handle, size_t frames)
+static size_t snd_pcm_mmap_playback_xfer(snd_pcm_t *handle, size_t frames)
 {
 	snd_pcm_mmap_control_t *control = handle->mmap_control;
-	size_t frames_cont;
+	size_t cont;
-	size_t frames_avail = snd_pcm_mmap_playback_frames_avail(handle);
+	size_t avail = snd_pcm_mmap_playback_avail(handle);
-	if (frames_avail < frames)
+	if (avail < frames)
-		frames = frames_avail;
+		frames = avail;
-	frames_cont = handle->setup.buffer_size - control->frame_data % handle->setup.buffer_size;
+	cont = handle->setup.buffer_size - control->appl_ptr % handle->setup.buffer_size;
-	if (frames_cont < frames)
+	if (cont < frames)
-		frames = frames_cont;
+		frames = cont;
 	return frames;
 }
 
-static size_t snd_pcm_mmap_capture_frames_xfer(snd_pcm_t *handle, size_t frames)
+static size_t snd_pcm_mmap_capture_xfer(snd_pcm_t *handle, size_t frames)
 {
 	snd_pcm_mmap_control_t *control = handle->mmap_control;
-	size_t frames_cont;
+	size_t cont;
-	size_t frames_avail = snd_pcm_mmap_capture_frames_avail(handle);
+	size_t avail = snd_pcm_mmap_capture_avail(handle);
-	if (frames_avail < frames)
+	if (avail < frames)
-		frames = frames_avail;
+		frames = avail;
-	frames_cont = handle->setup.buffer_size - control->frame_data % handle->setup.buffer_size;
+	cont = handle->setup.buffer_size - control->appl_ptr % handle->setup.buffer_size;
-	if (frames_cont < frames)
+	if (cont < frames)
-		frames = frames_cont;
+		frames = cont;
 	return frames;
 }
 
-ssize_t snd_pcm_mmap_frames_xfer(snd_pcm_t *handle, size_t frames)
+ssize_t snd_pcm_mmap_xfer(snd_pcm_t *handle, size_t frames)
 {
         assert(handle);
 	assert(handle->mmap_status && handle->mmap_control);
 	if (handle->stream == SND_PCM_STREAM_PLAYBACK)
-		return snd_pcm_mmap_playback_frames_xfer(handle, frames);
+		return snd_pcm_mmap_playback_xfer(handle, frames);
 	else
-		return snd_pcm_mmap_capture_frames_xfer(handle, frames);
+		return snd_pcm_mmap_capture_xfer(handle, frames);
 }
 
-ssize_t snd_pcm_mmap_frames_offset(snd_pcm_t *handle)
+ssize_t snd_pcm_mmap_offset(snd_pcm_t *handle)
 {
         assert(handle);
 	assert(handle->mmap_control);
-	return handle->mmap_control->frame_data % handle->setup.buffer_size;
+	return handle->mmap_control->appl_ptr % handle->setup.buffer_size;
 }
 
 int snd_pcm_mmap_state(snd_pcm_t *handle)
@@ -119,26 +119,26 @@ int snd_pcm_mmap_state(snd_pcm_t *handle)
 	return handle->mmap_status->state;
 }
 
-ssize_t snd_pcm_mmap_frame_io(snd_pcm_t *handle)
+ssize_t snd_pcm_mmap_hw_ptr(snd_pcm_t *handle)
 {
 	assert(handle);
 	assert(handle->mmap_status);
-	return handle->mmap_status->frame_io;
+	return handle->mmap_status->hw_ptr;
 }
 
-ssize_t snd_pcm_mmap_frame_data(snd_pcm_t *handle, off_t offset)
+ssize_t snd_pcm_mmap_appl_ptr(snd_pcm_t *handle, off_t offset)
 {
-	ssize_t frame_data;
+	ssize_t appl_ptr;
 	assert(handle);
 	assert(handle->mmap_status && handle->mmap_control);
 	assert(offset == 0 || handle->type == SND_PCM_TYPE_HW);
-	frame_data = handle->mmap_control->frame_data;
+	appl_ptr = handle->mmap_control->appl_ptr;
 	if (offset == 0)
-		return frame_data;
+		return appl_ptr;
 	switch (handle->mmap_status->state) {
 	case SND_PCM_STATE_RUNNING:
 		if (handle->setup.mode == SND_PCM_MODE_FRAME)
-			snd_pcm_frame_io(handle, 1);
+			snd_pcm_hw_ptr(handle, 1);
 		break;
 	case SND_PCM_STATE_READY:
 	case SND_PCM_STATE_NOTREADY:
@@ -148,25 +148,25 @@ ssize_t snd_pcm_mmap_frame_data(snd_pcm_t *handle, off_t offset)
 		if (offset < -(ssize_t)handle->setup.buffer_size)
 			offset = -(ssize_t)handle->setup.buffer_size;
 		else
-			offset -= offset % handle->setup.frames_align;
+			offset -= offset % handle->setup.align;
-		frame_data += offset;
+		appl_ptr += offset;
-		if (frame_data < 0)
+		if (appl_ptr < 0)
-			frame_data += handle->setup.frame_boundary;
+			appl_ptr += handle->setup.boundary;
 	} else {
-		size_t frames_avail;
+		size_t avail;
 		if (handle->stream == SND_PCM_STREAM_PLAYBACK)
-			frames_avail = snd_pcm_mmap_playback_frames_avail(handle);
+			avail = snd_pcm_mmap_playback_avail(handle);
 		else
-			frames_avail = snd_pcm_mmap_capture_frames_avail(handle);
+			avail = snd_pcm_mmap_capture_avail(handle);
-		if ((size_t)offset > frames_avail)
+		if ((size_t)offset > avail)
-			offset = frames_avail;
+			offset = avail;
-		offset -= offset % handle->setup.frames_align;
+		offset -= offset % handle->setup.align;
-		frame_data += offset;
+		appl_ptr += offset;
-		if ((size_t)frame_data >= handle->setup.frame_boundary)
+		if ((size_t)appl_ptr >= handle->setup.boundary)
-			frame_data -= handle->setup.frame_boundary;
+			appl_ptr -= handle->setup.boundary;
 	}
-	handle->mmap_control->frame_data = frame_data;
+	handle->mmap_control->appl_ptr = appl_ptr;
-	return frame_data;
+	return appl_ptr;
 }
 
 ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *handle, snd_pcm_channel_area_t *channels, size_t frames)
@@ -184,7 +184,7 @@ ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *handle, snd_pcm_channel_area_t *chan
 	} else {
 		if (status->state == SND_PCM_STATE_RUNNING &&
 		    handle->mode & SND_PCM_NONBLOCK)
-			snd_pcm_frame_io(handle, 1);
+			snd_pcm_hw_ptr(handle, 1);
 	}
 	while (frames > 0) {
 		ssize_t mmap_offset;
@@ -207,13 +207,13 @@ ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *handle, snd_pcm_channel_area_t *chan
 				return result > 0 ? result : -EPIPE;
 			assert(snd_pcm_mmap_playback_ready(handle));
 		}
-		frames1 = snd_pcm_mmap_playback_frames_xfer(handle, frames);
+		frames1 = snd_pcm_mmap_playback_xfer(handle, frames);
 		assert(frames1 > 0);
-		mmap_offset = snd_pcm_mmap_frames_offset(handle);
+		mmap_offset = snd_pcm_mmap_offset(handle);
 		snd_pcm_areas_copy(channels, offset, handle->channels, mmap_offset, handle->setup.format.channels, frames1, handle->setup.format.format);
 		if (status->state == SND_PCM_STATE_XRUN)
 			return result > 0 ? result : -EPIPE;
-		snd_pcm_frame_data(handle, frames1);
+		snd_pcm_appl_ptr(handle, frames1);
 		frames -= frames1;
 		offset += frames1;
 		result += frames1;
@@ -316,7 +316,7 @@ ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *handle, snd_pcm_channel_area_t *chann
 	} else {
 		if (status->state == SND_PCM_STATE_RUNNING &&
 		    handle->mode & SND_PCM_NONBLOCK)
-			snd_pcm_frame_io(handle, 1);
+			snd_pcm_hw_ptr(handle, 1);
 	}
 	if (status->state == SND_PCM_STATE_PREPARED &&
 	    handle->setup.start_mode == SND_PCM_START_DATA) {
@@ -345,14 +345,14 @@ ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *handle, snd_pcm_channel_area_t *chann
 				return result > 0 ? result : -EPIPE;
 			assert(snd_pcm_mmap_capture_ready(handle));
 		}
-		frames1 = snd_pcm_mmap_capture_frames_xfer(handle, frames);
+		frames1 = snd_pcm_mmap_capture_xfer(handle, frames);
 		assert(frames1 > 0);
-		mmap_offset = snd_pcm_mmap_frames_offset(handle);
+		mmap_offset = snd_pcm_mmap_offset(handle);
 		snd_pcm_areas_copy(handle->channels, mmap_offset, channels, offset, handle->setup.format.channels, frames1, handle->setup.format.format);
 		if (status->state == SND_PCM_STATE_XRUN &&
 		    handle->setup.xrun_mode == SND_PCM_XRUN_DRAIN)
 			return result > 0 ? result : -EPIPE;
-		snd_pcm_frame_data(handle, frames1);
+		snd_pcm_appl_ptr(handle, frames1);
 		frames -= frames1;
 		offset += frames1;
 		result += frames1;

src/pcm/pcm_multi.c

@@ -175,7 +175,7 @@ static int snd_pcm_multi_params(snd_pcm_t *pcm, snd_pcm_params_t *params)
 			p.format.interleave = 1;
 		p.format.channels = multi->slaves[i].channels_total;
 #if 1
-		p.frames_xrun_max = ~0;
+		p.xrun_max = ~0;
 #endif
 		err = snd_pcm_params(handle, &p);
 		if (err < 0)
@@ -211,7 +211,7 @@ static int snd_pcm_multi_setup(snd_pcm_t *pcm, snd_pcm_setup_t *setup)
 			return err;
 		if (setup->format.rate != s.format.rate)
 			return -EINVAL;
-		if (setup->frames_align % s.frames_align != 0)
+		if (setup->align % s.align != 0)
 			return -EINVAL;
 	}
 	setup->format.interleave = multi->interleave;
@@ -275,11 +275,11 @@ static int snd_pcm_multi_state(snd_pcm_t *pcm)
 	return snd_pcm_state(handle);
 }
 
-static ssize_t snd_pcm_multi_frame_io(snd_pcm_t *pcm, int update)
+static ssize_t snd_pcm_multi_hw_ptr(snd_pcm_t *pcm, int update)
 {
 	snd_pcm_multi_t *multi = pcm->private;
 	snd_pcm_t *handle = multi->slaves[0].handle;
-	return snd_pcm_frame_io(handle, update);
+	return snd_pcm_hw_ptr(handle, update);
 }
 
 static int snd_pcm_multi_prepare(snd_pcm_t *pcm)
@@ -367,25 +367,25 @@ static int snd_pcm_multi_channel_setup(snd_pcm_t *pcm, snd_pcm_channel_setup_t *
 	return 0;
 }
 
-static ssize_t snd_pcm_multi_frame_data(snd_pcm_t *pcm, off_t offset)
+static ssize_t snd_pcm_multi_appl_ptr(snd_pcm_t *pcm, off_t offset)
 {
 	snd_pcm_multi_t *multi = pcm->private;
 	ssize_t pos, newpos;
 	unsigned int i;
 	snd_pcm_t *handle_0 = multi->slaves[0].handle;
 
-	pos = snd_pcm_frame_data(handle_0, 0);
+	pos = snd_pcm_appl_ptr(handle_0, 0);
-	newpos = snd_pcm_frame_data(handle_0, offset);
+	newpos = snd_pcm_appl_ptr(handle_0, offset);
 	if (newpos < 0)
 		return newpos;
 	offset = newpos - pos;
 	if (offset < 0)
-		offset += handle_0->setup.frame_boundary;
+		offset += handle_0->setup.boundary;
 
 	for (i = 1; i < multi->slaves_count; ++i) {
 		snd_pcm_t *handle_i = multi->slaves[i].handle;
 		ssize_t newpos_i;
-		newpos_i = snd_pcm_frame_data(handle_i, offset);
+		newpos_i = snd_pcm_appl_ptr(handle_i, offset);
 		if (newpos_i < 0)
 			return newpos_i;
 		if (newpos_i != newpos)
@@ -578,7 +578,7 @@ static int snd_pcm_multi_mmap_control(snd_pcm_t *pcm, snd_pcm_mmap_control_t **c
 	unsigned int i;
 	for (i = 1; i < multi->slaves_count; ++i) {
 		snd_pcm_setup_t *setup = &multi->slaves[i].handle->setup;
-		/* Don't permit mmap if frame_data's have
+		/* Don't permit mmap if appl_ptr's have
 		   different ranges */
 		if (setup->buffer_size != setup_0->buffer_size)
 			return -EBADFD;
@@ -737,7 +737,7 @@ struct snd_pcm_fast_ops snd_pcm_multi_fast_ops = {
 	channel_params: snd_pcm_multi_channel_params,
 	channel_setup: snd_pcm_multi_channel_setup,
 	status: snd_pcm_multi_status,
-	frame_io: snd_pcm_multi_frame_io,
+	hw_ptr: snd_pcm_multi_hw_ptr,
 	state: snd_pcm_multi_state,
 	prepare: snd_pcm_multi_prepare,
 	go: snd_pcm_multi_go,
@@ -748,7 +748,7 @@ struct snd_pcm_fast_ops snd_pcm_multi_fast_ops = {
 	writev: snd_pcm_multi_writev,
 	read: snd_pcm_multi_read,
 	readv: snd_pcm_multi_readv,
-	frame_data: snd_pcm_multi_frame_data,
+	appl_ptr: snd_pcm_multi_appl_ptr,
 	mmap_status: snd_pcm_multi_mmap_status,
 	mmap_control: snd_pcm_multi_mmap_control,
 	mmap_data: snd_pcm_multi_mmap_data,

src/pcm/pcm_plug.c

@@ -270,14 +270,14 @@ static int snd_pcm_plug_setup(snd_pcm_t *pcm, snd_pcm_setup_t *setup)
 		return err;
 	if (!plug->first)
 		return 0;
-	setup->frame_boundary /= setup->frag_size;
+	setup->boundary /= setup->frag_size;
 	setup->frag_size = snd_pcm_plug_client_size(plug, setup->frag_size);
-	setup->frame_boundary *= setup->frag_size;
+	setup->boundary *= setup->frag_size;
 	setup->buffer_size = setup->frags * setup->frag_size;
-	setup->frames_min = snd_pcm_plug_client_size(plug, setup->frames_min);
+	setup->avail_min = snd_pcm_plug_client_size(plug, setup->avail_min);
-	setup->frames_align = snd_pcm_plug_client_size(plug, setup->frames_align);
+	setup->align = snd_pcm_plug_client_size(plug, setup->align);
-	setup->frames_xrun_max = snd_pcm_plug_client_size(plug, setup->frames_xrun_max);
+	setup->xrun_max = snd_pcm_plug_client_size(plug, setup->xrun_max);
-	setup->frames_fill_max = snd_pcm_plug_client_size(plug, setup->frames_fill_max);
+	setup->fill_max = snd_pcm_plug_client_size(plug, setup->fill_max);
 	setup->mmap_bytes = 0;
 	if (plug->handle->stream == SND_PCM_STREAM_PLAYBACK)
 		setup->format = plug->first->src_format;
@@ -301,10 +301,10 @@ static int snd_pcm_plug_status(snd_pcm_t *pcm, snd_pcm_status_t *status)
 	if (err < 0)
 		return err;
 
-	status->frame_io = snd_pcm_plug_client_size(plug, status->frame_io);
+	status->hw_ptr = snd_pcm_plug_client_size(plug, status->hw_ptr);
-	status->frame_data = snd_pcm_plug_client_size(plug, status->frame_data);
+	status->appl_ptr = snd_pcm_plug_client_size(plug, status->appl_ptr);
-	status->frames_avail = snd_pcm_plug_client_size(plug, status->frames_avail);
+	status->avail = snd_pcm_plug_client_size(plug, status->avail);
-	status->frames_avail_max = snd_pcm_plug_client_size(plug, status->frames_avail_max);
+	status->avail_max = snd_pcm_plug_client_size(plug, status->avail_max);
 	return 0;	
 }
 
@@ -314,13 +314,13 @@ static int snd_pcm_plug_state(snd_pcm_t *pcm)
 	return snd_pcm_state(plug->slave);
 }
 
-static ssize_t snd_pcm_plug_frame_io(snd_pcm_t *pcm, int update)
+static ssize_t snd_pcm_plug_hw_ptr(snd_pcm_t *pcm, int update)
 {
 	snd_pcm_plug_t *plug = pcm->private;
-	ssize_t frame_io = snd_pcm_frame_io(plug->slave, update);
+	ssize_t hw_ptr = snd_pcm_hw_ptr(plug->slave, update);
-	if (frame_io < 0)
+	if (hw_ptr < 0)
-		return frame_io;
+		return hw_ptr;
-	return snd_pcm_plug_client_size(plug, frame_io);
+	return snd_pcm_plug_client_size(plug, hw_ptr);
 }
 
 static int snd_pcm_plug_prepare(snd_pcm_t *pcm)
@@ -398,7 +398,7 @@ static int snd_pcm_plug_channel_setup(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_c
 	return -ENOSYS;
 }
 
-static ssize_t snd_pcm_plug_frame_data(snd_pcm_t *pcm, off_t offset)
+static ssize_t snd_pcm_plug_appl_ptr(snd_pcm_t *pcm, off_t offset)
 {
 	ssize_t ret;
 	snd_pcm_plug_t *plug = pcm->private;
@@ -412,7 +412,7 @@ static ssize_t snd_pcm_plug_frame_data(snd_pcm_t *pcm, off_t offset)
 		if (offset < 0)
 			return offset;
 	}
-	ret = snd_pcm_frame_data(plug->slave, offset);
+	ret = snd_pcm_appl_ptr(plug->slave, offset);
 	if (ret < 0)
 		return ret;
 	return snd_pcm_plug_client_size(plug, ret);
@@ -661,14 +661,14 @@ struct snd_pcm_fast_ops snd_pcm_plug_fast_ops = {
 	channel_params: snd_pcm_plug_channel_params,
 	channel_setup: snd_pcm_plug_channel_setup,
 	status: snd_pcm_plug_status,
-	frame_io: snd_pcm_plug_frame_io,
+	hw_ptr: snd_pcm_plug_hw_ptr,
 	state: snd_pcm_plug_state,
 	prepare: snd_pcm_plug_prepare,
 	go: snd_pcm_plug_go,
 	drain: snd_pcm_plug_drain,
 	flush: snd_pcm_plug_flush,
 	pause: snd_pcm_plug_pause,
-	frame_data: snd_pcm_plug_frame_data,
+	appl_ptr: snd_pcm_plug_appl_ptr,
 	write: snd_pcm_plug_write,
 	writev: snd_pcm_plug_writev,
 	read: snd_pcm_plug_read,
@@ -690,18 +690,18 @@ static void snd_pcm_plug_slave_params(snd_pcm_plug_t *plug,
 	/* compute right sizes */
 	slave_params->frag_size = snd_pcm_plug_slave_size(plug, params->frag_size);
 	slave_params->buffer_size = snd_pcm_plug_slave_size(plug, params->buffer_size);
-	slave_params->frames_fill_max = snd_pcm_plug_slave_size(plug, params->frames_fill_max);
+	slave_params->fill_max = snd_pcm_plug_slave_size(plug, params->fill_max);
-	slave_params->frames_min = snd_pcm_plug_slave_size(plug, params->frames_min);
+	slave_params->avail_min = snd_pcm_plug_slave_size(plug, params->avail_min);
-	slave_params->frames_xrun_max = snd_pcm_plug_slave_size(plug, params->frames_xrun_max);
+	slave_params->xrun_max = snd_pcm_plug_slave_size(plug, params->xrun_max);
-	slave_params->frames_align = snd_pcm_plug_slave_size(plug, params->frames_align);
+	slave_params->align = snd_pcm_plug_slave_size(plug, params->align);
-	if (slave_params->frame_boundary == 0 || slave_params->frame_boundary > LONG_MAX)
+	if (slave_params->boundary == 0 || slave_params->boundary > LONG_MAX)
-		slave_params->frame_boundary = LONG_MAX;
+		slave_params->boundary = LONG_MAX;
 	assert(params->buffer_size > 0);
-	slave_params->frame_boundary /= params->buffer_size;
+	slave_params->boundary /= params->buffer_size;
-	if (slave_params->frame_boundary > LONG_MAX / slave_params->buffer_size)
+	if (slave_params->boundary > LONG_MAX / slave_params->buffer_size)
-		slave_params->frame_boundary = LONG_MAX;
+		slave_params->boundary = LONG_MAX;
 	else
-		slave_params->frame_boundary *= slave_params->buffer_size;
+		slave_params->boundary *= slave_params->buffer_size;
 }
 
 

src/pcm/plugin/mmap.c

@@ -80,8 +80,8 @@ static ssize_t mmap_src_channels(snd_pcm_plugin_t *plugin,
 			return -EPIPE;
 		assert(snd_pcm_mmap_ready(stream));
 	}
-	pos = snd_pcm_mmap_frames_offset(stream);
+	pos = snd_pcm_mmap_offset(stream);
-	assert(pos % setup->frames_align == 0);
+	assert(pos % setup->align == 0);
 
 	sv = plugin->buf_channels;
 	dv = stream->channels;
@@ -99,7 +99,7 @@ static ssize_t mmap_src_channels(snd_pcm_plugin_t *plugin,
 		++sv;
 		++dv;
 	}
-	return snd_pcm_mmap_frames_xfer(stream, frames);
+	return snd_pcm_mmap_xfer(stream, frames);
 }
 
 static ssize_t mmap_dst_channels(snd_pcm_plugin_t *plugin,
@@ -147,8 +147,8 @@ static ssize_t mmap_dst_channels(snd_pcm_plugin_t *plugin,
 			return -EPIPE;
 		assert(snd_pcm_mmap_ready(stream));
 	}
-	pos = snd_pcm_mmap_frames_offset(stream);
+	pos = snd_pcm_mmap_offset(stream);
-	assert(pos % setup->frames_align == 0);
+	assert(pos % setup->align == 0);
 
 	sv = stream->channels;
 	dv = plugin->buf_channels;
@@ -162,7 +162,7 @@ static ssize_t mmap_dst_channels(snd_pcm_plugin_t *plugin,
 		++sv;
 		++dv;
 	}
-	return snd_pcm_mmap_frames_xfer(stream, frames);
+	return snd_pcm_mmap_xfer(stream, frames);
 }
 
 static ssize_t mmap_playback_transfer(snd_pcm_plugin_t *plugin,
@@ -188,7 +188,7 @@ static ssize_t mmap_playback_transfer(snd_pcm_plugin_t *plugin,
 	}
 #endif
 
-	err = snd_pcm_frame_data(stream, frames);
+	err = snd_pcm_appl_ptr(stream, frames);
 	if (err < 0)
 		return err;
 	if (snd_pcm_mmap_state(stream) == SND_PCM_STATE_PREPARED &&
@@ -216,7 +216,7 @@ static ssize_t mmap_capture_transfer(snd_pcm_plugin_t *plugin,
 	stream = plugin->plug->slave;
 
 	/* FIXME: not here the increment */
-	err = snd_pcm_frame_data(stream, frames);
+	err = snd_pcm_appl_ptr(stream, frames);
 	if (err < 0)
 		return err;
 

test/latency.c

@@ -59,7 +59,7 @@ int setparams(snd_pcm_t *phandle, snd_pcm_t *chandle, int *bufsize)
 	if (*bufsize > LATENCY_MAX)
 		return -1;
 	params.frag_size = *bufsize / 2;
-	params.frames_min = 1;
+	params.avail_min = 1;
 	params.buffer_size = *bufsize;
 
 	if ((err = snd_pcm_params(phandle, &params)) < 0) {
@@ -109,9 +109,9 @@ void showstat(snd_pcm_t *handle, snd_pcm_status_t *rstatus, size_t frames)
 	}
 	printf("  state = %i\n", status.state);
 	printf("  frames = %i\n", frames);
-	printf("  frame_io = %li\n", (long)status.frame_io);
+	printf("  hw_ptr = %li\n", (long)status.hw_ptr);
-	printf("  frame_data = %li\n", (long)status.frame_data);
+	printf("  appl_ptr = %li\n", (long)status.appl_ptr);
-	printf("  frames_avail = %li\n", (long)status.frames_avail);
+	printf("  avail = %li\n", (long)status.avail);
 	if (rstatus)
 		*rstatus = status;
 }