Some cleaning renames. Prepared API for new plugins

diff --git a/include/aserver.h b/include/aserver.h
index 0094b2da9dc6e2ef3032dcb53e79f465c934a210..fb7164ed40b60c39d00de742f94a7b96adf6966a 100644 (file)
--- a/include/aserver.h
+++ b/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;
-               int frame_io;
+               off_t appl_ptr;
+               int hw_ptr;
                int link;
                snd_xfer_t read;
                snd_xfer_t write;

diff --git a/include/pcm.h b/include/pcm.h
index 0e67cf7168faeac8f3dd145ff8e7332da7a88993..25a20e023f4447a6dad20ffd212197fe7fb8fd7b 100644 (file)
--- a/include/pcm.h
+++ b/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_frame_data(snd_pcm_t *handle, off_t offset);
+ssize_t snd_pcm_hw_ptr(snd_pcm_t *handle, int update);
+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_frame_data(snd_pcm_t *handle, off_t offset);
+ssize_t snd_pcm_mmap_hw_ptr(snd_pcm_t *handle);
+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);
-ssize_t snd_pcm_mmap_frames_xfer(snd_pcm_t *handle, size_t frames);
-ssize_t snd_pcm_mmap_frames_offset(snd_pcm_t *handle);
+int snd_pcm_mmap_avail(snd_pcm_t *handle, ssize_t *frames);
+ssize_t snd_pcm_mmap_xfer(snd_pcm_t *handle, size_t frames);
+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);

diff --git a/src/aserver/aserver.c b/src/aserver/aserver.c
index 362441cbdf81e4bfa2225b9cc8977656b33ec0b5..a4e7449bd3feb4e9665abc4e5734ce182906e249 100644 (file)
--- a/src/aserver/aserver.c
+++ b/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:
-               ctrl->result = snd_pcm_frame_io(pcm, ctrl->u.frame_io);
+       case SND_PCM_IOCTL_HW_PTR:
+               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:
-               ctrl->result = snd_pcm_frame_data(pcm, ctrl->u.frame_data);
+       case SND_PCM_IOCTL_APPL_PTR:
+               ctrl->result = snd_pcm_appl_ptr(pcm, ctrl->u.appl_ptr);
                break;
        case SND_PCM_IOCTL_LINK:
        {

diff --git a/src/pcm/pcm.c b/src/pcm/pcm.c
index fffd6c12a69260bcb6179c47d4d9672d6535644b..82a7a218d5df6967147c9884c1c2768816df3368 100644 (file)
--- a/src/pcm/pcm.c
+++ b/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->fast_ops->frame_io(handle->fast_op_arg, update);
+               return handle->mmap_status->hw_ptr;
+       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, "frames_align: %ld\n", (long)setup->frames_align);
-       fprintf(fp, "frames_xrun_max: %ld\n", (long)setup->frames_xrun_max);
+       fprintf(fp, "avail_min: %ld\n", (long)setup->avail_min);
+       fprintf(fp, "align: %ld\n", (long)setup->align);
+       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;
 }
 

diff --git a/src/pcm/pcm_client.c b/src/pcm/pcm_client.c
index 8d721256e6e31f1ff32be96526be315ce231ddba..d0b865bcb95e96d11e06bf58078e820136460c43 100644 (file)
--- a/src/pcm/pcm_client.c
+++ b/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->u.frame_io = update;
+       ctrl->cmd = SND_PCM_IOCTL_HW_PTR;
+       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->u.frame_data = offset;
+       ctrl->cmd = SND_PCM_IOCTL_APPL_PTR;
+       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,

diff --git a/src/pcm/pcm_hw.c b/src/pcm/pcm_hw.c
index dce890a9f016f19bdff377edaac33b83442857ef..fa229af73af682b26fe0aaafe119a4fcd2452c48 100644 (file)
--- a/src/pcm/pcm_hw.c
+++ b/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);
-       result = ioctl(fd, SND_PCM_IOCTL_FRAME_DATA, offset);
+               return snd_pcm_mmap_appl_ptr(pcm, 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,

diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h
index 4511af852495c408d5f68c18a42d4a9e1f7b1f0c..8cabad136ef6a93a2dcebca9ad1e6b40f65e55a1 100644 (file)
--- a/src/pcm/pcm_local.h
+++ b/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 (*frame_data)(snd_pcm_t *pcm, off_t offset);
+       ssize_t (*hw_ptr)(snd_pcm_t *pcm, int update);
+       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;
-       frames_avail = str->mmap_status->frame_io + str->setup.buffer_size - str->mmap_control->frame_data;
-       if (frames_avail < 0)
-               frames_avail += str->setup.frame_boundary;
-       return frames_avail;
+       ssize_t avail;
+       avail = str->mmap_status->hw_ptr + str->setup.buffer_size - str->mmap_control->appl_ptr;
+       if (avail < 0)
+               avail += str->setup.boundary;
+       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;
-       frames_avail = str->mmap_status->frame_io - str->mmap_control->frame_data;
-       if (frames_avail < 0)
-               frames_avail += str->setup.frame_boundary;
-       return frames_avail;
+       ssize_t avail;
+       avail = str->mmap_status->hw_ptr - str->mmap_control->appl_ptr;
+       if (avail < 0)
+               avail += str->setup.boundary;
+       return avail;
 }
 
 #define snd_pcm_plug_stream(plug) ((plug)->handle->stream)

diff --git a/src/pcm/pcm_mmap.c b/src/pcm/pcm_mmap.c
index 441becf65d2a0edbcced3a1b4e12f50c196e0dc8..fdb5a08e8d677d95e949fa2e50b6496dfa71e4c7 100644 (file)
--- a/src/pcm/pcm_mmap.c
+++ b/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 frames_avail = snd_pcm_mmap_playback_frames_avail(handle);
-       if (frames_avail < frames)
-               frames = frames_avail;
-       frames_cont = handle->setup.buffer_size - control->frame_data % handle->setup.buffer_size;
-       if (frames_cont < frames)
-               frames = frames_cont;
+       size_t cont;
+       size_t avail = snd_pcm_mmap_playback_avail(handle);
+       if (avail < frames)
+               frames = avail;
+       cont = handle->setup.buffer_size - control->appl_ptr % handle->setup.buffer_size;
+       if (cont < frames)
+               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 frames_avail = snd_pcm_mmap_capture_frames_avail(handle);
-       if (frames_avail < frames)
-               frames = frames_avail;
-       frames_cont = handle->setup.buffer_size - control->frame_data % handle->setup.buffer_size;
-       if (frames_cont < frames)
-               frames = frames_cont;
+       size_t cont;
+       size_t avail = snd_pcm_mmap_capture_avail(handle);
+       if (avail < frames)
+               frames = avail;
+       cont = handle->setup.buffer_size - control->appl_ptr % handle->setup.buffer_size;
+       if (cont < frames)
+               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;
-               frame_data += offset;
-               if (frame_data < 0)
-                       frame_data += handle->setup.frame_boundary;
+                       offset -= offset % handle->setup.align;
+               appl_ptr += offset;
+               if (appl_ptr < 0)
+                       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);
-               if ((size_t)offset > frames_avail)
-                       offset = frames_avail;
-               offset -= offset % handle->setup.frames_align;
-               frame_data += offset;
-               if ((size_t)frame_data >= handle->setup.frame_boundary)
-                       frame_data -= handle->setup.frame_boundary;
+                       avail = snd_pcm_mmap_capture_avail(handle);
+               if ((size_t)offset > avail)
+                       offset = avail;
+               offset -= offset % handle->setup.align;
+               appl_ptr += offset;
+               if ((size_t)appl_ptr >= handle->setup.boundary)
+                       appl_ptr -= handle->setup.boundary;
        }
-       handle->mmap_control->frame_data = frame_data;
-       return frame_data;
+       handle->mmap_control->appl_ptr = appl_ptr;
+       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;

diff --git a/src/pcm/pcm_multi.c b/src/pcm/pcm_multi.c
index 41c19e7440145e223e716094e12d6597e75ab2b5..18578d72007c4af6c6c3fff11f8c155ce9915eab 100644 (file)
--- a/src/pcm/pcm_multi.c
+++ b/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);
-       newpos = snd_pcm_frame_data(handle_0, offset);
+       pos = snd_pcm_appl_ptr(handle_0, 0);
+       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,

diff --git a/src/pcm/pcm_plug.c b/src/pcm/pcm_plug.c
index a4387e92e05d952853aa40903156c938b4fdcf80..adb41aae0814caac10386e6d4da3236f269928a5 100644 (file)
--- a/src/pcm/pcm_plug.c
+++ b/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->frames_align = snd_pcm_plug_client_size(plug, setup->frames_align);
-       setup->frames_xrun_max = snd_pcm_plug_client_size(plug, setup->frames_xrun_max);
-       setup->frames_fill_max = snd_pcm_plug_client_size(plug, setup->frames_fill_max);
+       setup->avail_min = snd_pcm_plug_client_size(plug, setup->avail_min);
+       setup->align = snd_pcm_plug_client_size(plug, setup->align);
+       setup->xrun_max = snd_pcm_plug_client_size(plug, setup->xrun_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->frame_data = snd_pcm_plug_client_size(plug, status->frame_data);
-       status->frames_avail = snd_pcm_plug_client_size(plug, status->frames_avail);
-       status->frames_avail_max = snd_pcm_plug_client_size(plug, status->frames_avail_max);
+       status->hw_ptr = snd_pcm_plug_client_size(plug, status->hw_ptr);
+       status->appl_ptr = snd_pcm_plug_client_size(plug, status->appl_ptr);
+       status->avail = snd_pcm_plug_client_size(plug, status->avail);
+       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);
-       if (frame_io < 0)
-               return frame_io;
-       return snd_pcm_plug_client_size(plug, frame_io);
+       ssize_t hw_ptr = snd_pcm_hw_ptr(plug->slave, update);
+       if (hw_ptr < 0)
+               return hw_ptr;
+       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->frames_min = snd_pcm_plug_slave_size(plug, params->frames_min);
-       slave_params->frames_xrun_max = snd_pcm_plug_slave_size(plug, params->frames_xrun_max);
-       slave_params->frames_align = snd_pcm_plug_slave_size(plug, params->frames_align);
-       if (slave_params->frame_boundary == 0 || slave_params->frame_boundary > LONG_MAX)
-               slave_params->frame_boundary = LONG_MAX;
+       slave_params->fill_max = snd_pcm_plug_slave_size(plug, params->fill_max);
+       slave_params->avail_min = snd_pcm_plug_slave_size(plug, params->avail_min);
+       slave_params->xrun_max = snd_pcm_plug_slave_size(plug, params->xrun_max);
+       slave_params->align = snd_pcm_plug_slave_size(plug, params->align);
+       if (slave_params->boundary == 0 || slave_params->boundary > LONG_MAX)
+               slave_params->boundary = LONG_MAX;
        assert(params->buffer_size > 0);
-       slave_params->frame_boundary /= params->buffer_size;
-       if (slave_params->frame_boundary > LONG_MAX / slave_params->buffer_size)
-               slave_params->frame_boundary = LONG_MAX;
+       slave_params->boundary /= params->buffer_size;
+       if (slave_params->boundary > LONG_MAX / slave_params->buffer_size)
+               slave_params->boundary = LONG_MAX;
        else
-               slave_params->frame_boundary *= slave_params->buffer_size;
+               slave_params->boundary *= slave_params->buffer_size;
 }
 
 

diff --git a/src/pcm/plugin/mmap.c b/src/pcm/plugin/mmap.c
index 481fe8e835f9b61cc47cd6ee09008f59f5a8386f..db1f6a49bf61369e2a02364da49d435f5e99c883 100644 (file)
--- a/src/pcm/plugin/mmap.c
+++ b/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);
-       assert(pos % setup->frames_align == 0);
+       pos = snd_pcm_mmap_offset(stream);
+       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);
-       assert(pos % setup->frames_align == 0);
+       pos = snd_pcm_mmap_offset(stream);
+       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;
 

diff --git a/test/latency.c b/test/latency.c
index 33f2fd23f13c67b968cf525ae5f77c1d50b1a856..961d1e68bf9c7dc9593caa021a09591998853779 100644 (file)
--- a/test/latency.c
+++ b/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("  frame_data = %li\n", (long)status.frame_data);
-       printf("  frames_avail = %li\n", (long)status.frames_avail);
+       printf("  hw_ptr = %li\n", (long)status.hw_ptr);
+       printf("  appl_ptr = %li\n", (long)status.appl_ptr);
+       printf("  avail = %li\n", (long)status.avail);
        if (rstatus)
                *rstatus = status;
 }