Added mmap_control access function. Converted static checks in asserts. Uniformed...

diff --git a/include/pcm.h b/include/pcm.h
index 30b782435e45b40042fac606c243d37231c2ace1..9b70b17f3ed11d702bb4d3d02350d93e028b5a07 100644 (file)
--- a/include/pcm.h
+++ b/include/pcm.h
@@ -112,10 +112,14 @@ int snd_pcm_capture_flush(snd_pcm_t *handle);
 int snd_pcm_stream_flush(snd_pcm_t *handle, int stream);
 int snd_pcm_playback_pause(snd_pcm_t *handle, int enable);
 int snd_pcm_stream_pause(snd_pcm_t *handle, int stream, int enable);
-ssize_t snd_pcm_transfer_size(snd_pcm_t *handle, int stream);
 int snd_pcm_stream_state(snd_pcm_t *handle, int stream);
+int snd_pcm_mmap_stream_state(snd_pcm_t *handle, int stream);
 ssize_t snd_pcm_stream_byte_io(snd_pcm_t *handle, int stream, int update);
+ssize_t snd_pcm_mmap_stream_byte_io(snd_pcm_t *handle, int stream);
+ssize_t snd_pcm_stream_byte_data(snd_pcm_t *handle, int stream);
+ssize_t snd_pcm_mmap_stream_byte_data(snd_pcm_t *handle, int stream);
 ssize_t snd_pcm_stream_seek(snd_pcm_t *pcm, int stream, off_t offset);
+ssize_t snd_pcm_mmap_stream_seek(snd_pcm_t *pcm, int stream, 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 *pcm, const struct iovec *vector, unsigned long  count);
@@ -137,11 +141,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 *pcm, const struct iovec *vector, unsigned long  count);
 ssize_t snd_pcm_mmap_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned long count);
-int snd_pcm_mmap_frames_used(snd_pcm_t *pcm, int stream, ssize_t *frames);
-int snd_pcm_mmap_frames_free(snd_pcm_t *pcm, int stream, ssize_t *frames);
+int snd_pcm_mmap_frames_avail(snd_pcm_t *pcm, int stream, ssize_t *frames);
 ssize_t snd_pcm_mmap_frames_xfer(snd_pcm_t *pcm, int stream, size_t frames);
 ssize_t snd_pcm_mmap_frames_offset(snd_pcm_t *pcm, int stream);
-int snd_pcm_mmap_commit_frames(snd_pcm_t *pcm, int stream, int frames);
 ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels, size_t frames);
 ssize_t snd_pcm_mmap_write_frames(snd_pcm_t *pcm, const void *buffer, size_t frames);
 ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels, size_t frames);
@@ -161,6 +163,7 @@ int snd_pcm_areas_copy(const snd_pcm_channel_area_t *src_channels, size_t src_of
                       const snd_pcm_channel_area_t *dst_channels, size_t dst_offset,
                       size_t vcount, size_t frames, int format);
 
+
 /* misc */
 
 int snd_pcm_format_signed(int format);

diff --git a/src/pcm/pcm.c b/src/pcm/pcm.c
index 0f2047f6cb389c6fc0697b6dbbdc5adbe76fb5a3..d7e1661aecf55d3cbb576c239147b664c1fc4a9f 100644 (file)
--- a/src/pcm/pcm.c
+++ b/src/pcm/pcm.c
@@ -25,6 +25,7 @@
 #include <errno.h>
 #include <sys/poll.h>
 #include <sys/uio.h>
+#include <assert.h>
 #include "pcm_local.h"
 
 int snd_pcm_abstract_open(snd_pcm_t **handle, int mode,
@@ -32,8 +33,7 @@ int snd_pcm_abstract_open(snd_pcm_t **handle, int mode,
 {
        snd_pcm_t *pcm;
 
-       if (!handle)
-               return -EFAULT;
+       assert(handle);
        *handle = NULL;
 
        pcm = (snd_pcm_t *) calloc(1, sizeof(snd_pcm_t) + extra);
@@ -65,13 +65,10 @@ int snd_pcm_stream_close(snd_pcm_t *pcm, int stream)
        int ret = 0;
        int err;
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
+       assert(str->open);
        if (str->mmap_control) {
                if ((err = snd_pcm_munmap_control(pcm, stream)) < 0)
                        ret = err;
@@ -92,8 +89,7 @@ int snd_pcm_close(snd_pcm_t *pcm)
        int err, ret = 0;
        int stream;
 
-       if (!pcm)
-               return -EFAULT;
+       assert(pcm);
        for (stream = 0; stream < 2; ++stream) {
                if (pcm->stream[stream].open) {
                        if ((err = snd_pcm_stream_close(pcm, stream)) < 0)
@@ -107,26 +103,24 @@ int snd_pcm_close(snd_pcm_t *pcm)
 int snd_pcm_stream_nonblock(snd_pcm_t *pcm, int stream, int nonblock)
 {
        int err;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
+       snd_pcm_stream_t *str;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       str = &pcm->stream[stream];
+       assert(pcm->stream[stream].open);
        if ((err = pcm->ops->stream_nonblock(pcm, stream, nonblock)) < 0)
                return err;
        if (nonblock)
-               pcm->stream[stream].mode |= SND_PCM_NONBLOCK;
+               str->mode |= SND_PCM_NONBLOCK;
        else
-               pcm->stream[stream].mode &= ~SND_PCM_NONBLOCK;
+               str->mode &= ~SND_PCM_NONBLOCK;
        return 0;
 }
 
 int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
 {
        int stream;
-       if (!pcm || !info)
-               return -EFAULT;
+       assert(pcm && info);
        for (stream = 0; stream < 2; ++stream) {
                if (pcm->stream[stream].open)
                        return pcm->ops->info(pcm, stream, info);
@@ -136,12 +130,9 @@ int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
 
 int snd_pcm_stream_info(snd_pcm_t *pcm, snd_pcm_stream_info_t *info)
 {
-       if (!pcm || !info)
-               return -EFAULT;
-       if (info->stream < 0 || info->stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[info->stream].open)
-               return -EBADFD;
+       assert(pcm && info);
+       assert(info->stream >= 0 && info->stream <= 1);
+       assert(pcm->stream[info->stream].open);
        return pcm->ops->stream_info(pcm, info);
 }
 
@@ -150,15 +141,11 @@ int snd_pcm_stream_params(snd_pcm_t *pcm, snd_pcm_stream_params_t *params)
        int err;
        snd_pcm_stream_setup_t setup;
        snd_pcm_stream_t *str;
-       if (!pcm || !params)
-               return -EFAULT;
-       if (params->stream < 0 || params->stream > 1)
-               return -EINVAL;
+       assert(pcm && params);
+       assert(params->stream >= 0 && params->stream <= 1);
        str = &pcm->stream[params->stream];
-       if (!str->open)
-               return -EBADFD;
-       if (str->mmap_control)
-               return -EBADFD;
+       assert(str->open);
+       assert(!str->mmap_data);
        if ((err = pcm->ops->stream_params(pcm, params)) < 0)
                return err;
        str->valid_setup = 0;
@@ -170,13 +157,10 @@ int snd_pcm_stream_setup(snd_pcm_t *pcm, snd_pcm_stream_setup_t *setup)
 {
        int err;
        snd_pcm_stream_t *str;
-       if (!pcm || !setup)
-               return -EFAULT;
-       if (setup->stream < 0 || setup->stream > 1)
-               return -EINVAL;
+       assert(pcm && setup);
+       assert(setup->stream >= 0 && setup->stream <= 1);
        str = &pcm->stream[setup->stream];
-       if (!str->open)
-               return -EBADFD;
+       assert(str->open);
        if (str->valid_setup) {
                memcpy(setup, &str->setup, sizeof(*setup));
                return 0;
@@ -194,50 +178,38 @@ int snd_pcm_stream_setup(snd_pcm_t *pcm, snd_pcm_stream_setup_t *setup)
 const snd_pcm_stream_setup_t* snd_pcm_stream_cached_setup(snd_pcm_t *pcm, int stream)
 {
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return 0;
-       if (stream < 0 || stream > 1)
-               return 0;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open || !str->valid_setup)
-               return 0;
+       assert(str->valid_setup);
        return &str->setup;
 }
 
 int snd_pcm_channel_setup(snd_pcm_t *pcm, int stream, snd_pcm_channel_setup_t *setup)
 {
        snd_pcm_stream_t *str;
-       if (!pcm || !setup)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm && setup);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
+       assert(str->valid_setup);
        return pcm->ops->channel_setup(pcm, stream, setup);
 }
 
 int snd_pcm_stream_status(snd_pcm_t *pcm, snd_pcm_stream_status_t *status)
 {
-       if (!pcm || !status)
-               return -EFAULT;
-       if (status->stream < 0 || status->stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[status->stream].open)
-               return -EBADFD;
+       assert(pcm && status);
+       assert(status->stream >= 0 && status->stream <= 1);
+       assert(pcm->stream[status->stream].open);
        return pcm->ops->stream_status(pcm, status);
 }
 
 int snd_pcm_stream_state(snd_pcm_t *pcm, int stream)
 {
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
+       assert(str->open);
        if (str->mmap_control)
                return str->mmap_control->status;
        return pcm->ops->stream_state(pcm, stream);
@@ -246,26 +218,32 @@ int snd_pcm_stream_state(snd_pcm_t *pcm, int stream)
 int snd_pcm_stream_byte_io(snd_pcm_t *pcm, int stream, int update)
 {
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
+       assert(str->valid_setup);
        if (str->mmap_control && !update)
                return str->mmap_control->byte_io;
        return pcm->ops->stream_byte_io(pcm, stream, update);
 }
 
+int snd_pcm_stream_byte_data(snd_pcm_t *pcm, int stream)
+{
+       snd_pcm_stream_t *str;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       str = &pcm->stream[stream];
+       assert(str->valid_setup);
+       if (str->mmap_control)
+               return str->mmap_control->byte_data;
+       return pcm->ops->stream_seek(pcm, stream, 0);
+}
+
 int snd_pcm_stream_prepare(snd_pcm_t *pcm, int stream)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].open);
        return pcm->ops->stream_prepare(pcm, stream);
 }
 
@@ -282,13 +260,10 @@ int snd_pcm_capture_prepare(snd_pcm_t *pcm)
 int snd_pcm_stream_go(snd_pcm_t *pcm, int stream)
 {
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
+       assert(str->valid_setup);
        return pcm->ops->stream_go(pcm, stream);
 }
 
@@ -305,8 +280,7 @@ int snd_pcm_capture_go(snd_pcm_t *pcm)
 int snd_pcm_sync_go(snd_pcm_t *pcm, snd_pcm_sync_t *sync)
 {
        int stream;
-       if (!pcm || !sync)
-               return -EFAULT;
+       assert(pcm && sync);
        for (stream = 0; stream < 2; ++stream) {
                if (pcm->stream[stream].open)
                        return pcm->ops->sync_go(pcm, stream, sync);
@@ -316,14 +290,10 @@ int snd_pcm_sync_go(snd_pcm_t *pcm, snd_pcm_sync_t *sync)
 
 int snd_pcm_stream_drain(snd_pcm_t *pcm, int stream)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
-       if (stream != SND_PCM_STREAM_PLAYBACK)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].open);
+       assert(stream == SND_PCM_STREAM_PLAYBACK);
        return pcm->ops->stream_drain(pcm, stream);
 }
 
@@ -334,13 +304,9 @@ int snd_pcm_playback_drain(snd_pcm_t *pcm)
 
 int snd_pcm_stream_flush(snd_pcm_t *pcm, int stream)
 {
-       int err;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].open);
        return pcm->ops->stream_flush(pcm, stream);
 }
 
@@ -356,15 +322,10 @@ int snd_pcm_capture_flush(snd_pcm_t *pcm)
 
 int snd_pcm_stream_pause(snd_pcm_t *pcm, int stream, int enable)
 {
-       int err;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
-       if (stream != SND_PCM_STREAM_PLAYBACK)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].open);
+       assert(stream == SND_PCM_STREAM_PLAYBACK);
        return pcm->ops->stream_pause(pcm, stream, enable);
 }
 
@@ -373,124 +334,74 @@ int snd_pcm_playback_pause(snd_pcm_t *pcm, int enable)
        return snd_pcm_stream_pause(pcm, SND_PCM_STREAM_PLAYBACK, enable);
 }
 
-ssize_t snd_pcm_transfer_size(snd_pcm_t *pcm, int stream)
-{
-       snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
-       if (!str->valid_setup)
-               return -EBADFD;
-       if (str->setup.mode != SND_PCM_MODE_FRAGMENT)
-               return -EBADFD;
-       return str->setup.frag_size;
-}
-
 ssize_t snd_pcm_stream_seek(snd_pcm_t *pcm, int stream, off_t offset)
 {
        snd_pcm_stream_t *str;
-       size_t bytes_per_frame;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
-       if (!str->valid_setup)
-               return -EBADFD;
-#if 0
-       /* TODO */
-       if (str->mmap_control) {
-       } else
-#endif
+       assert(str->valid_setup);
+       if (str->mmap_control)
+               return snd_pcm_mmap_stream_seek(pcm, stream, offset);
+       else
                return pcm->ops->stream_seek(pcm, stream, offset);
 }
 
 ssize_t snd_pcm_write(snd_pcm_t *pcm, const void *buffer, size_t size)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (!pcm->stream[SND_PCM_STREAM_PLAYBACK].open ||
-           !pcm->stream[SND_PCM_STREAM_PLAYBACK].valid_setup)
-               return -EBADFD;
-       if (size > 0 && !buffer)
-               return -EFAULT;
+       assert(pcm);
+       assert(pcm->stream[SND_PCM_STREAM_PLAYBACK].valid_setup);
+       assert(size == 0 || buffer);
        return pcm->ops->write(pcm, buffer, size);
 }
 
 ssize_t snd_pcm_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned long count)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (!pcm->stream[SND_PCM_STREAM_PLAYBACK].open ||
-           !pcm->stream[SND_PCM_STREAM_PLAYBACK].valid_setup)
-               return -EBADFD;
-       if (count > 0 && !vector)
-               return -EFAULT;
+       assert(pcm);
+       assert(pcm->stream[SND_PCM_STREAM_PLAYBACK].valid_setup);
+       assert(count == 0 || vector);
        return pcm->ops->writev(pcm, vector, count);
 }
 
 ssize_t snd_pcm_read(snd_pcm_t *pcm, void *buffer, size_t size)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (!pcm->stream[SND_PCM_STREAM_CAPTURE].open ||
-           !pcm->stream[SND_PCM_STREAM_CAPTURE].valid_setup)
-               return -EBADFD;
-       if (size > 0 && !buffer)
-               return -EFAULT;
+       assert(pcm);
+       assert(pcm->stream[SND_PCM_STREAM_CAPTURE].valid_setup);
+       assert(size == 0 || buffer);
        return pcm->ops->read(pcm, buffer, size);
 }
 
 ssize_t snd_pcm_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned long count)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (!pcm->stream[SND_PCM_STREAM_CAPTURE].open ||
-           !pcm->stream[SND_PCM_STREAM_CAPTURE].valid_setup)
-               return -EBADFD;
-       if (count > 0 && !vector)
-               return -EFAULT;
+       assert(pcm);
+       assert(pcm->stream[SND_PCM_STREAM_CAPTURE].valid_setup);
+       assert(count == 0 || vector);
        return pcm->ops->readv(pcm, vector, count);
 }
 
 int snd_pcm_file_descriptor(snd_pcm_t* pcm, int stream)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].open);
        return pcm->ops->file_descriptor(pcm, stream);
 }
 
 int snd_pcm_channels_mask(snd_pcm_t *pcm, int stream, bitset_t *client_vmask)
 {
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].valid_setup);
        return pcm->ops->channels_mask(pcm, stream, client_vmask);
 }
 
 ssize_t snd_pcm_bytes_per_second(snd_pcm_t *pcm, int stream)
 {
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
+       assert(str->valid_setup);
        return snd_pcm_format_bytes_per_second(&str->setup.format);
 }
 
@@ -578,13 +489,10 @@ int snd_pcm_dump_setup(snd_pcm_t *pcm, int stream, FILE *fp)
 {
        snd_pcm_stream_t *str;
        snd_pcm_stream_setup_t *setup;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
+       assert(str->valid_setup);
        setup = &str->setup;
        fprintf(fp, "stream: %s\n", assoc(setup->stream, streams));
        fprintf(fp, "mode: %s\n", assoc(setup->mode, modes));

diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h
index 51fb11bc5774245dfd57974ffcdd4c696a97fdb5..cb6c0d4aeca797895c32409a21d36f75b0dcf9ee 100644 (file)
--- a/src/pcm/pcm_local.h
+++ b/src/pcm/pcm_local.h
@@ -79,6 +79,7 @@ typedef struct {
        size_t mmap_control_size;
        char *mmap_data;
        size_t mmap_data_size;
+       enum { _INTERLEAVED, _NONINTERLEAVED, _COMPLEX } mmap_type;
 } snd_pcm_stream_t;
 
 struct snd_pcm {
@@ -131,21 +132,19 @@ int conv_index(int src_format, int dst_format);
 #define pdprintf( args... ) { ; }
 #endif
 
-static inline ssize_t snd_pcm_mmap_playback_bytes_used(snd_pcm_stream_t *str)
+static inline size_t snd_pcm_mmap_playback_bytes_avail(snd_pcm_stream_t *str)
 {
-       ssize_t bytes_used;
-       bytes_used = str->mmap_control->byte_data - str->mmap_control->byte_io;
-       if (bytes_used < (ssize_t)(str->setup.buffer_size - str->setup.byte_boundary))
-               bytes_used += str->setup.byte_boundary;
-       return bytes_used;
+       ssize_t bytes_avail = str->mmap_control->byte_io + str->setup.buffer_size - str->mmap_control->byte_data;
+       if (bytes_avail < 0)
+               bytes_avail += str->setup.byte_boundary;
+       return bytes_avail;
 }
 
-static inline size_t snd_pcm_mmap_capture_bytes_used(snd_pcm_stream_t *str)
+static inline size_t snd_pcm_mmap_capture_bytes_avail(snd_pcm_stream_t *str)
 {
-       ssize_t bytes_used;
-       bytes_used = str->mmap_control->byte_io - str->mmap_control->byte_data;
-       if (bytes_used < 0)
-               bytes_used += str->setup.byte_boundary;
-       return bytes_used;
+       ssize_t bytes_avail = str->mmap_control->byte_io - str->mmap_control->byte_data;
+       if (bytes_avail < 0)
+               bytes_avail += str->setup.byte_boundary;
+       return bytes_avail;
 }
 

diff --git a/src/pcm/pcm_mmap.c b/src/pcm/pcm_mmap.c
index 0efb34f44aa9cfe8e77ecd82a9ce8a4a29d919dd..77a4d4e26c45b6fb6b70a58b46680d6f9a62d726 100644 (file)
--- a/src/pcm/pcm_mmap.c
+++ b/src/pcm/pcm_mmap.c
@@ -26,21 +26,21 @@
 #include <sys/uio.h>
 #include "pcm_local.h"
 
-static ssize_t snd_pcm_mmap_playback_frames_used(snd_pcm_t *pcm)
+static ssize_t snd_pcm_mmap_playback_frames_avail(snd_pcm_t *pcm)
 {
        snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       ssize_t bytes = snd_pcm_mmap_playback_bytes_used(str);
+       ssize_t bytes = snd_pcm_mmap_playback_bytes_avail(str);
        return bytes * 8 / str->bits_per_frame;
 }
 
-static size_t snd_pcm_mmap_capture_frames_used(snd_pcm_t *pcm)
+static size_t snd_pcm_mmap_capture_frames_avail(snd_pcm_t *pcm)
 {
        snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       size_t bytes = snd_pcm_mmap_capture_bytes_used(str);
+       size_t bytes = snd_pcm_mmap_capture_bytes_avail(str);
        return bytes * 8 / str->bits_per_frame;
 }
 
-int snd_pcm_mmap_frames_used(snd_pcm_t *pcm, int stream, ssize_t *frames)
+int snd_pcm_frames_avail(snd_pcm_t *pcm, int stream, ssize_t *frames)
 {
        snd_pcm_stream_t *str;
         if (!pcm)
@@ -48,53 +48,12 @@ int snd_pcm_mmap_frames_used(snd_pcm_t *pcm, int stream, ssize_t *frames)
         if (stream < 0 || stream > 1)
                 return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open || !str->mmap_control)
-               return -EBADFD;
-       if (stream == SND_PCM_STREAM_PLAYBACK)
-               *frames = snd_pcm_mmap_playback_frames_used(pcm);
-       else
-               *frames = snd_pcm_mmap_capture_frames_used(pcm);
-       return 0;
-}
-
-static inline size_t snd_pcm_mmap_playback_bytes_free(snd_pcm_stream_t *str)
-{
-       return str->setup.buffer_size - snd_pcm_mmap_playback_bytes_used(str);
-}
-
-static size_t snd_pcm_mmap_playback_frames_free(snd_pcm_t *pcm)
-{
-       snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       size_t bytes = snd_pcm_mmap_playback_bytes_free(str);
-       return bytes * 8 / str->bits_per_frame;
-}
-
-static inline ssize_t snd_pcm_mmap_capture_bytes_free(snd_pcm_stream_t *str)
-{
-       return str->setup.buffer_size - snd_pcm_mmap_capture_bytes_used(str);
-}
-
-static ssize_t snd_pcm_mmap_capture_frames_free(snd_pcm_t *pcm)
-{
-       snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       ssize_t bytes = snd_pcm_mmap_capture_bytes_free(str);
-       return bytes * 8 / str->bits_per_frame;
-}
-
-int snd_pcm_mmap_frames_free(snd_pcm_t *pcm, int stream, ssize_t *frames)
-{
-       snd_pcm_stream_t *str;
-        if (!pcm)
-                return -EFAULT;
-        if (stream < 0 || stream > 1)
-                return -EINVAL;
-       str = &pcm->stream[stream];
-       if (!str->open || !str->mmap_control)
+       if (!str->mmap_control)
                return -EBADFD;
        if (stream == SND_PCM_STREAM_PLAYBACK)
-               *frames = snd_pcm_mmap_playback_frames_free(pcm);
+               *frames = snd_pcm_mmap_playback_frames_avail(pcm);
        else
-               *frames = snd_pcm_mmap_capture_frames_free(pcm);
+               *frames = snd_pcm_mmap_capture_frames_avail(pcm);
        return 0;
 }
 
@@ -104,7 +63,7 @@ static int snd_pcm_mmap_playback_ready(snd_pcm_t *pcm)
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
        if (str->mmap_control->status == SND_PCM_STATUS_XRUN)
                return -EPIPE;
-       return (str->setup.buffer_size - snd_pcm_mmap_playback_bytes_used(str)) >= str->setup.bytes_min;
+       return snd_pcm_mmap_playback_bytes_avail(str) >= str->setup.bytes_min;
 }
 
 static int snd_pcm_mmap_capture_ready(snd_pcm_t *pcm)
@@ -117,7 +76,7 @@ static int snd_pcm_mmap_capture_ready(snd_pcm_t *pcm)
                if (str->setup.xrun_mode == SND_PCM_XRUN_DRAIN)
                        return -EPIPE;
        }
-       if (snd_pcm_mmap_capture_bytes_used(str) >= str->setup.bytes_min)
+       if (snd_pcm_mmap_capture_bytes_avail(str) >= str->setup.bytes_min)
                return 1;
        return ret;
 }
@@ -131,7 +90,7 @@ int snd_pcm_mmap_ready(snd_pcm_t *pcm, int stream)
         if (stream < 0 || stream > 1)
                 return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open || !str->mmap_control)
+       if (!str->mmap_control)
                return -EBADFD;
        ctrl = str->mmap_control;
        if (ctrl->status < SND_PCM_STATUS_PREPARED)
@@ -148,14 +107,12 @@ static size_t snd_pcm_mmap_playback_bytes_xfer(snd_pcm_t *pcm, size_t bytes)
        snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
        snd_pcm_mmap_control_t *ctrl = str->mmap_control;
        size_t bytes_cont;
-       size_t byte_data = ctrl->byte_data;
-       size_t bytes_free = snd_pcm_mmap_playback_bytes_free(str);
-       if (bytes_free < bytes)
-               bytes = bytes_free;
-       bytes_cont = str->setup.buffer_size - (byte_data % str->setup.buffer_size);
+       size_t bytes_avail = snd_pcm_mmap_playback_bytes_avail(str);
+       if (bytes_avail < bytes)
+               bytes = bytes_avail;
+       bytes_cont = str->setup.buffer_size - ctrl->byte_data % str->setup.buffer_size;
        if (bytes_cont < bytes)
                bytes = bytes_cont;
-       bytes -= bytes % str->setup.bytes_align;
        return bytes;
 }
 
@@ -164,14 +121,12 @@ static size_t snd_pcm_mmap_capture_bytes_xfer(snd_pcm_t *pcm, size_t bytes)
        snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
        snd_pcm_mmap_control_t *ctrl = str->mmap_control;
        size_t bytes_cont;
-       size_t byte_data = ctrl->byte_data;
-       size_t bytes_used = snd_pcm_mmap_capture_bytes_used(str);
-       if (bytes_used < bytes)
-               bytes = bytes_used;
-       bytes_cont = str->setup.buffer_size - (byte_data % str->setup.buffer_size);
+       size_t bytes_avail = snd_pcm_mmap_capture_bytes_avail(str);
+       if (bytes_avail < bytes)
+               bytes = bytes_avail;
+       bytes_cont = str->setup.buffer_size - ctrl->byte_data % str->setup.buffer_size;
        if (bytes_cont < bytes)
                bytes = bytes_cont;
-       bytes -= bytes % str->setup.bytes_align;
        return bytes;
 }
 
@@ -199,7 +154,7 @@ ssize_t snd_pcm_mmap_frames_xfer(snd_pcm_t *pcm, int stream, size_t frames)
         if (stream < 0 || stream > 1)
                 return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open || !str->mmap_control)
+       if (!str->mmap_control)
                return -EBADFD;
        if (stream == SND_PCM_STREAM_PLAYBACK)
                return snd_pcm_mmap_playback_frames_xfer(pcm, frames);
@@ -216,7 +171,7 @@ ssize_t snd_pcm_mmap_frames_offset(snd_pcm_t *pcm, int stream)
         if (stream < 0 || stream > 1)
                 return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open)
+       if (!str->mmap_control)
                return -EBADFD;
        ctrl = str->mmap_control;
        if (!ctrl)
@@ -224,32 +179,80 @@ ssize_t snd_pcm_mmap_frames_offset(snd_pcm_t *pcm, int stream)
        return (ctrl->byte_data % str->setup.buffer_size) * 8 / str->bits_per_frame;
 }
 
-int snd_pcm_mmap_commit_frames(snd_pcm_t *pcm, int stream, int frames)
+int snd_pcm_mmap_stream_state(snd_pcm_t *pcm, int stream)
 {
        snd_pcm_stream_t *str;
-       snd_pcm_mmap_control_t *ctrl;
-       size_t byte_data, bytes;
-        if (!pcm)
-                return -EFAULT;
-        if (stream < 0 || stream > 1)
-                return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
-       ctrl = str->mmap_control;
-       if (!ctrl)
+       assert(str->mmap_control);
+       return str->mmap_control->status;
+}
+
+int snd_pcm_mmap_stream_byte_io(snd_pcm_t *pcm, int stream)
+{
+       snd_pcm_stream_t *str;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       str = &pcm->stream[stream];
+       assert(str->mmap_control);
+       return str->mmap_control->byte_io;
+}
+
+int snd_pcm_mmap_stream_byte_data(snd_pcm_t *pcm, int stream)
+{
+       snd_pcm_stream_t *str;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       str = &pcm->stream[stream];
+       assert(str->mmap_control);
+       return str->mmap_control->byte_data;
+}
+
+ssize_t snd_pcm_mmap_stream_seek(snd_pcm_t *pcm, int stream, off_t offset)
+{
+       snd_pcm_stream_t *str;
+       ssize_t byte_data;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       str = &pcm->stream[stream];
+       assert(str->mmap_control);
+       byte_data = str->mmap_control->byte_data;
+       if (offset == 0)
+               return byte_data;
+       switch (str->mmap_control->status) {
+       case SND_PCM_STATUS_RUNNING:
+               if (str->setup.mode == SND_PCM_MODE_FRAME)
+                       snd_pcm_stream_byte_io(pcm, stream, 1);
+               break;
+       case SND_PCM_STATUS_PREPARED:
+               break;
+       default:
                return -EBADFD;
-       bytes = frames * str->bits_per_frame;
-       if (bytes % 8)
-               return -EINVAL;
-       bytes /= 8;
-       byte_data = ctrl->byte_data + bytes;
-       if (byte_data == str->setup.byte_boundary) {
-               ctrl->byte_data = 0;
+       }
+       if (offset < 0) {
+               if (offset < -(ssize_t)str->setup.buffer_size)
+                       offset = -(ssize_t)str->setup.buffer_size;
+               else
+                       offset -= offset % str->setup.bytes_align;
+               byte_data += offset;
+               if (byte_data < 0)
+                       byte_data += str->setup.byte_boundary;
        } else {
-               ctrl->byte_data = byte_data;
+               size_t bytes_avail;
+               if (stream == SND_PCM_STREAM_PLAYBACK)
+                       bytes_avail = snd_pcm_mmap_playback_bytes_avail(str);
+               else
+                       bytes_avail = snd_pcm_mmap_capture_bytes_avail(str);
+               if ((size_t)offset > bytes_avail)
+                       offset = bytes_avail;
+               offset -= offset % str->setup.bytes_align;
+               byte_data += offset;
+               if ((size_t)byte_data >= str->setup.byte_boundary)
+                       byte_data -= str->setup.byte_boundary;
        }
-       return 0;
+       str->mmap_control->byte_data = byte_data;
+       return byte_data;
 }
 
 ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels, size_t frames)
@@ -299,7 +302,7 @@ ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channel
                snd_pcm_areas_copy(channels, offset, str->channels, mmap_offset, str->setup.format.channels, frames1, str->setup.format.format);
                if (ctrl->status == SND_PCM_STATUS_XRUN)
                        return result > 0 ? result : -EPIPE;
-               snd_pcm_mmap_commit_frames(pcm, SND_PCM_STREAM_PLAYBACK, frames1);
+               snd_pcm_stream_seek(pcm, SND_PCM_STREAM_PLAYBACK, frames1 * str->bits_per_frame / 8);
                frames -= frames1;
                offset += frames1;
                result += frames1;
@@ -322,8 +325,6 @@ ssize_t snd_pcm_mmap_write_frames(snd_pcm_t *pcm, const void *buffer, size_t fra
        if (!pcm)
                return -EFAULT;
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
        if (!str->mmap_data || !str->mmap_control)
                return -EBADFD;
        if (frames > 0 && !buffer)
@@ -351,8 +352,6 @@ ssize_t snd_pcm_mmap_write(snd_pcm_t *pcm, const void *buffer, size_t bytes)
        if (!pcm)
                return -EFAULT;
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
        if (!str->mmap_data || !str->mmap_control)
                return -EBADFD;
        if (bytes > 0 && !buffer)
@@ -375,8 +374,6 @@ ssize_t snd_pcm_mmap_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned
        if (!pcm)
                return -EFAULT;
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
        if (!str->mmap_data || !str->mmap_control)
                return -EBADFD;
        if (vcount > 0 && !vector)
@@ -485,7 +482,7 @@ ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels
                if (ctrl->status == SND_PCM_STATUS_XRUN &&
                    str->setup.xrun_mode == SND_PCM_XRUN_DRAIN)
                        return result > 0 ? result : -EPIPE;
-               snd_pcm_mmap_commit_frames(pcm, SND_PCM_STREAM_CAPTURE, frames1);
+               snd_pcm_stream_seek(pcm, SND_PCM_STREAM_CAPTURE, frames1 * str->bits_per_frame / 8);
                frames -= frames1;
                offset += frames1;
                result += frames1;
@@ -500,8 +497,6 @@ ssize_t snd_pcm_mmap_read_frames(snd_pcm_t *pcm, const void *buffer, size_t fram
        if (!pcm)
                return -EFAULT;
        str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
        if (!str->mmap_data || !str->mmap_control)
                return -EBADFD;
        if (frames > 0 && !buffer)
@@ -529,8 +524,6 @@ ssize_t snd_pcm_mmap_read(snd_pcm_t *pcm, void *buffer, size_t bytes)
        if (!pcm)
                return -EFAULT;
        str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
        if (!str->mmap_data || !str->mmap_control)
                return -EBADFD;
        if (bytes > 0 && !buffer)
@@ -553,8 +546,6 @@ ssize_t snd_pcm_mmap_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned
        if (!pcm)
                return -EFAULT;
        str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       if (!str->open || !str->valid_setup)
-               return -EBADFD;
        if (!str->mmap_data || !str->mmap_control)
                return -EBADFD;
        if (vcount > 0 && !vector)
@@ -609,36 +600,9 @@ ssize_t snd_pcm_mmap_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned
        return result * str->bits_per_frame / 8;
 }
 
-static ssize_t mmap_playback_bytes_xfer(snd_pcm_stream_t *str)
-{
-       snd_pcm_mmap_control_t *ctrl = str->mmap_control;
-       size_t bytes_cont;
-       size_t byte_io = ctrl->byte_io;
-       ssize_t bytes = snd_pcm_mmap_playback_bytes_used(str);
-       bytes_cont = str->setup.buffer_size - (byte_io % str->setup.buffer_size);
-       if ((ssize_t)bytes_cont < bytes)
-               bytes = bytes_cont;
-       bytes -= bytes % str->setup.bytes_align;
-       return bytes;
-}
-
-static ssize_t mmap_capture_bytes_xfer(snd_pcm_stream_t *str)
-{
-       snd_pcm_mmap_control_t *ctrl = str->mmap_control;
-       size_t bytes_cont;
-       size_t byte_io = ctrl->byte_io;
-       ssize_t bytes = snd_pcm_mmap_capture_bytes_free(str);
-       bytes_cont = str->setup.buffer_size - (byte_io % str->setup.buffer_size);
-       if ((ssize_t)bytes_cont < bytes)
-               bytes = bytes_cont;
-       bytes -= bytes % str->setup.bytes_align;
-       return bytes;
-}
-
 int snd_pcm_mmap_control(snd_pcm_t *pcm, int stream, snd_pcm_mmap_control_t **control)
 {
        snd_pcm_stream_t *str;
-       snd_pcm_stream_info_t info;
        size_t csize;
        int err;
        if (!pcm || !control)
@@ -646,14 +610,12 @@ int snd_pcm_mmap_control(snd_pcm_t *pcm, int stream, snd_pcm_mmap_control_t **co
        if (stream < 0 || stream > 1)
                return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open)
+       if (!str->valid_setup)
                return -EBADFD;
        if (str->mmap_control) {
                *control = str->mmap_control;
                return 0;
        }
-       if (!str->valid_setup)
-               return -EBADFD;
        csize = sizeof(snd_pcm_mmap_control_t);
 
        if ((err = pcm->ops->mmap_control(pcm, stream, control, csize)) < 0)
@@ -669,13 +631,14 @@ int snd_pcm_mmap_get_areas(snd_pcm_t *pcm, int stream, snd_pcm_channel_area_t *a
        snd_pcm_channel_setup_t s;
        snd_pcm_channel_area_t *a, *ap;
        unsigned int channel;
+       int interleaved = 1, noninterleaved = 1;
        int err;
        if (!pcm)
                return -EFAULT;
        if (stream < 0 || stream > 1)
                return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open || !str->valid_setup || !str->mmap_data)
+       if (!str->mmap_data)
                return -EBADFD;
        a = calloc(str->setup.format.channels, sizeof(*areas));
        for (channel = 0, ap = a; channel < str->setup.format.channels; ++channel, ++ap) {
@@ -688,7 +651,19 @@ int snd_pcm_mmap_get_areas(snd_pcm_t *pcm, int stream, snd_pcm_channel_area_t *a
                if (areas)
                        areas[channel] = s.area;
                *ap = s.area;
+               if (ap->step != str->sample_width || ap->first != 0)
+                       noninterleaved = 0;
+               if (ap->addr != a[0].addr || 
+                   ap->step != str->bits_per_frame || 
+                   ap->first != channel * str->sample_width)
+                       interleaved = 0;
        }
+       if (noninterleaved)
+               str->mmap_type = _NONINTERLEAVED;
+       else if (interleaved)
+               str->mmap_type = _INTERLEAVED;
+       else
+               str->mmap_type = _COMPLEX;
        str->channels = a;
        return 0;
 }
@@ -704,14 +679,12 @@ int snd_pcm_mmap_data(snd_pcm_t *pcm, int stream, void **data)
        if (stream < 0 || stream > 1)
                return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open)
+       if (!str->valid_setup)
                return -EBADFD;
        if (str->mmap_data) {
                *data = str->mmap_data;
                return 0;
        }
-       if (!str->valid_setup)
-               return -EBADFD;
 
        info.stream = stream;
        err = snd_pcm_stream_info(pcm, &info);
@@ -753,10 +726,8 @@ int snd_pcm_munmap_control(snd_pcm_t *pcm, int stream)
        if (stream < 0 || stream > 1)
                return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
        if (!str->mmap_control)
-               return -EINVAL;
+               return -EBADFD;
        if ((err = pcm->ops->munmap_control(pcm, stream, str->mmap_control, str->mmap_control_size)) < 0)
                return err;
        str->mmap_control = 0;
@@ -773,10 +744,8 @@ int snd_pcm_munmap_data(snd_pcm_t *pcm, int stream)
        if (stream < 0 || stream > 1)
                return -EINVAL;
        str = &pcm->stream[stream];
-       if (!str->open)
-               return -EBADFD;
        if (!str->mmap_data)
-               return -EINVAL;
+               return -EBADFD;
        if ((err = pcm->ops->munmap_data(pcm, stream, str->mmap_data, str->mmap_data_size)) < 0)
                return err;
        free(str->channels);

diff --git a/src/pcm/pcm_plug.c b/src/pcm/pcm_plug.c
index 7b04caaa7e24e753e7cc0dc80c6d418c3ab908b4..505f938e8bef7451e1668f4a59ad89148a831dd9 100644 (file)
--- a/src/pcm/pcm_plug.c
+++ b/src/pcm/pcm_plug.c
@@ -310,7 +310,7 @@ static int snd_pcm_plug_stream_nonblock(snd_pcm_t *pcm, int stream, int nonblock
        return snd_pcm_stream_nonblock(plug->slave, stream, nonblock);
 }
 
-static int snd_pcm_plug_info(snd_pcm_t *pcm, int stream, snd_pcm_info_t * info)
+static int snd_pcm_plug_info(snd_pcm_t *pcm, int stream UNUSED, snd_pcm_info_t * info)
 {
        snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private;
        return snd_pcm_info(plug->slave, info);
@@ -534,7 +534,7 @@ static int snd_pcm_plug_stream_go(snd_pcm_t *pcm, int stream)
        return snd_pcm_stream_go(plug->slave, stream);
 }
 
-static int snd_pcm_plug_sync_go(snd_pcm_t *pcm, int stream, snd_pcm_sync_t *sync)
+static int snd_pcm_plug_sync_go(snd_pcm_t *pcm, int stream UNUSED, snd_pcm_sync_t *sync)
 {
        snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private;
        return snd_pcm_sync_go(plug->slave, sync);

diff --git a/src/pcm/plugin/mmap.c b/src/pcm/plugin/mmap.c
index 4372b73bca660d9d2dbd083f8939276ed4c2cd98..4425658c84fec05669422d1f97ca1b2f57322b97 100644 (file)
--- a/src/pcm/plugin/mmap.c
+++ b/src/pcm/plugin/mmap.c
@@ -187,7 +187,7 @@ static ssize_t mmap_playback_transfer(snd_pcm_plugin_t *plugin,
        mmap_t *data;
        snd_pcm_stream_setup_t *setup;
        snd_pcm_mmap_control_t *ctrl;
-       snd_pcm_stream_t *stream;
+       snd_pcm_stream_t *str;
        int err;
 
        if (plugin == NULL)
@@ -200,8 +200,8 @@ static ssize_t mmap_playback_transfer(snd_pcm_plugin_t *plugin,
        ctrl = data->control;
        if (ctrl == NULL)
                return -EINVAL;
-       stream = &data->slave->stream[SND_PCM_STREAM_PLAYBACK];
-       setup = &stream->setup;
+       str = &data->slave->stream[SND_PCM_STREAM_PLAYBACK];
+       setup = &str->setup;
 
 #if 0
        for (channel = 0; channel < plugin->src_format.channels; channel++) {
@@ -210,10 +210,10 @@ static ssize_t mmap_playback_transfer(snd_pcm_plugin_t *plugin,
        }
 #endif
 
-       snd_pcm_mmap_commit_frames(data->slave, SND_PCM_STREAM_PLAYBACK, frames);
+       snd_pcm_stream_seek(data->slave, SND_PCM_STREAM_PLAYBACK, frames * str->bits_per_frame / 8);
        if (ctrl->status == SND_PCM_STATUS_PREPARED &&
-           (stream->setup.start_mode == SND_PCM_START_DATA ||
-            (stream->setup.start_mode == SND_PCM_START_FULL &&
+           (str->setup.start_mode == SND_PCM_START_DATA ||
+            (str->setup.start_mode == SND_PCM_START_FULL &&
              !snd_pcm_mmap_ready(data->slave, plugin->stream)))) {
                err = snd_pcm_stream_go(data->slave, plugin->stream);
                if (err < 0)
@@ -228,8 +228,8 @@ static ssize_t mmap_capture_transfer(snd_pcm_plugin_t *plugin,
                                     size_t frames)
 {
        mmap_t *data;
-       snd_pcm_stream_setup_t *setup;
        snd_pcm_mmap_control_t *ctrl;
+       snd_pcm_stream_t *str;
 
        if (plugin == NULL)
                return -EINVAL;
@@ -240,10 +240,11 @@ static ssize_t mmap_capture_transfer(snd_pcm_plugin_t *plugin,
        ctrl = data->control;
        if (ctrl == NULL)
                return -EINVAL;
-       setup = &data->slave->stream[SND_PCM_STREAM_CAPTURE].setup;
+       str = &data->slave->stream[SND_PCM_STREAM_CAPTURE];
 
        /* FIXME: not here the increment */
-       snd_pcm_mmap_commit_frames(data->slave, SND_PCM_STREAM_CAPTURE, frames);
+       snd_pcm_stream_seek(data->slave, SND_PCM_STREAM_CAPTURE, frames * str->bits_per_frame / 8);
+
        return frames;
 }