From f11e203d6eb3611bf1f9c02ac6926d4615c815c8 Mon Sep 17 00:00:00 2001 From: Abramo Bagnara Date: Thu, 1 Jun 2000 21:58:25 +0000 Subject: [PATCH] Added snd_pcm_stream_state and snd_pcm_stream_byte_io. Added needed callbacks and cleaned some existing. Fixed byte_boundary request --- include/pcm.h | 5 +- src/pcm/Makefile.am | 4 +- src/pcm/pcm.c | 76 ++++++++++++++++++++--------- src/pcm/pcm_common.c | 28 +++++------ src/pcm/pcm_hw.c | 53 ++++++++++++-------- src/pcm/pcm_local.h | 53 +++++++++++--------- src/pcm/pcm_mmap.c | 88 +++++++++++++-------------------- src/pcm/pcm_plug.c | 111 +++++++++++++++++------------------------- src/pcm/plugin/mmap.c | 6 +-- 9 files changed, 216 insertions(+), 208 deletions(-) diff --git a/include/pcm.h b/include/pcm.h index f595f0c9..30b78243 100644 --- a/include/pcm.h +++ b/include/pcm.h @@ -82,7 +82,7 @@ static inline void bitset_one(bitset_t *dst, unsigned int nbits) typedef struct snd_pcm snd_pcm_t; typedef struct snd_pcm_loopback snd_pcm_loopback_t; -typedef enum { SND_PCM_TYPE_HW, SND_PCM_TYPE_PLUG } snd_pcm_type_t; +typedef enum { SND_PCM_TYPE_HW, SND_PCM_TYPE_PLUG, SND_PCM_TYPE_MULTI } snd_pcm_type_t; int snd_pcm_open(snd_pcm_t **handle, int card, int device, int mode); int snd_pcm_open_subdevice(snd_pcm_t **handle, int card, int device, int subdevice, int mode); @@ -98,7 +98,6 @@ int snd_pcm_stream_params(snd_pcm_t *handle, snd_pcm_stream_params_t *params); int snd_pcm_stream_setup(snd_pcm_t *handle, snd_pcm_stream_setup_t *setup); int snd_pcm_channel_setup(snd_pcm_t *handle, int stream, snd_pcm_channel_setup_t *setup); int snd_pcm_stream_status(snd_pcm_t *handle, snd_pcm_stream_status_t *status); -int snd_pcm_stream_update(snd_pcm_t *handle, int stream); int snd_pcm_playback_prepare(snd_pcm_t *handle); int snd_pcm_capture_prepare(snd_pcm_t *handle); int snd_pcm_stream_prepare(snd_pcm_t *handle, int stream); @@ -114,6 +113,8 @@ 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); +ssize_t snd_pcm_stream_byte_io(snd_pcm_t *handle, int stream, int update); ssize_t snd_pcm_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); diff --git a/src/pcm/Makefile.am b/src/pcm/Makefile.am index 89222aed..148201bd 100644 --- a/src/pcm/Makefile.am +++ b/src/pcm/Makefile.am @@ -2,8 +2,8 @@ SUBDIRS = plugin EXTRA_LTLIBRARIES = libpcm.la -libpcm_la_SOURCES = pcm.c pcm_hw.c pcm_plug.c pcm_common.c pcm_misc.c \ - pcm_mmap.c +libpcm_la_SOURCES = pcm.c pcm_hw.c pcm_plug.c pcm_common.c \ + pcm_misc.c pcm_mmap.c libpcm_la_LIBADD = plugin/libpcmplugin.la noinst_HEADERS = pcm_local.h diff --git a/src/pcm/pcm.c b/src/pcm/pcm.c index bca6189a..0f2047f6 100644 --- a/src/pcm/pcm.c +++ b/src/pcm/pcm.c @@ -40,12 +40,12 @@ int snd_pcm_abstract_open(snd_pcm_t **handle, int mode, if (pcm == NULL) return -ENOMEM; if (mode & SND_PCM_OPEN_PLAYBACK) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; str->open = 1; str->mode = (mode & SND_PCM_NONBLOCK_PLAYBACK) ? SND_PCM_NONBLOCK : 0; } if (mode & SND_PCM_OPEN_CAPTURE) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; str->open = 1; str->mode = (mode & SND_PCM_NONBLOCK_CAPTURE) ? SND_PCM_NONBLOCK : 0; } @@ -64,7 +64,7 @@ int snd_pcm_stream_close(snd_pcm_t *pcm, int stream) { int ret = 0; int err; - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -124,9 +124,14 @@ int snd_pcm_stream_nonblock(snd_pcm_t *pcm, int stream, int nonblock) int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info) { + int stream; if (!pcm || !info) return -EFAULT; - return pcm->ops->info(pcm, info); + for (stream = 0; stream < 2; ++stream) { + if (pcm->stream[stream].open) + return pcm->ops->info(pcm, stream, info); + } + return -EBADFD; } int snd_pcm_stream_info(snd_pcm_t *pcm, snd_pcm_stream_info_t *info) @@ -144,7 +149,7 @@ int snd_pcm_stream_params(snd_pcm_t *pcm, snd_pcm_stream_params_t *params) { int err; snd_pcm_stream_setup_t setup; - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm || !params) return -EFAULT; if (params->stream < 0 || params->stream > 1) @@ -164,7 +169,7 @@ int snd_pcm_stream_params(snd_pcm_t *pcm, snd_pcm_stream_params_t *params) int snd_pcm_stream_setup(snd_pcm_t *pcm, snd_pcm_stream_setup_t *setup) { int err; - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm || !setup) return -EFAULT; if (setup->stream < 0 || setup->stream > 1) @@ -188,7 +193,7 @@ 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) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return 0; if (stream < 0 || stream > 1) @@ -201,7 +206,7 @@ const snd_pcm_stream_setup_t* snd_pcm_stream_cached_setup(snd_pcm_t *pcm, int st int snd_pcm_channel_setup(snd_pcm_t *pcm, int stream, snd_pcm_channel_setup_t *setup) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm || !setup) return -EFAULT; if (stream < 0 || stream > 1) @@ -223,15 +228,34 @@ int snd_pcm_stream_status(snd_pcm_t *pcm, snd_pcm_stream_status_t *status) return pcm->ops->stream_status(pcm, status); } -int snd_pcm_stream_update(snd_pcm_t *pcm, int stream) +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; - if (!pcm->stream[stream].open) + str = &pcm->stream[stream]; + if (!str->open) + return -EBADFD; + if (str->mmap_control) + return str->mmap_control->status; + return pcm->ops->stream_state(pcm, 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; + str = &pcm->stream[stream]; + if (!str->open) return -EBADFD; - return pcm->ops->stream_update(pcm, stream); + if (str->mmap_control && !update) + return str->mmap_control->byte_io; + return pcm->ops->stream_byte_io(pcm, stream, update); } int snd_pcm_stream_prepare(snd_pcm_t *pcm, int stream) @@ -257,7 +281,7 @@ int snd_pcm_capture_prepare(snd_pcm_t *pcm) int snd_pcm_stream_go(snd_pcm_t *pcm, int stream) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -280,12 +304,14 @@ 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; - if (!pcm->stream[SND_PCM_STREAM_PLAYBACK].open && - !pcm->stream[SND_PCM_STREAM_CAPTURE].open) - return -EBADFD; - return pcm->ops->sync_go(pcm, sync); + for (stream = 0; stream < 2; ++stream) { + if (pcm->stream[stream].open) + return pcm->ops->sync_go(pcm, stream, sync); + } + return -EBADFD; } int snd_pcm_stream_drain(snd_pcm_t *pcm, int stream) @@ -349,7 +375,7 @@ int snd_pcm_playback_pause(snd_pcm_t *pcm, int enable) ssize_t snd_pcm_transfer_size(snd_pcm_t *pcm, int stream) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -366,7 +392,7 @@ ssize_t snd_pcm_transfer_size(snd_pcm_t *pcm, int stream) ssize_t snd_pcm_stream_seek(snd_pcm_t *pcm, int stream, off_t offset) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; size_t bytes_per_frame; if (!pcm) return -EFAULT; @@ -377,10 +403,12 @@ ssize_t snd_pcm_stream_seek(snd_pcm_t *pcm, int stream, off_t offset) return -EBADFD; if (!str->valid_setup) return -EBADFD; - bytes_per_frame = str->bits_per_frame / 8; - if (bytes_per_frame > 0) - offset -= offset % bytes_per_frame; - return pcm->ops->stream_seek(pcm, stream, offset); +#if 0 + /* TODO */ + if (str->mmap_control) { + } else +#endif + return pcm->ops->stream_seek(pcm, stream, offset); } ssize_t snd_pcm_write(snd_pcm_t *pcm, const void *buffer, size_t size) @@ -455,7 +483,7 @@ int snd_pcm_channels_mask(snd_pcm_t *pcm, int stream, bitset_t *client_vmask) ssize_t snd_pcm_bytes_per_second(snd_pcm_t *pcm, int stream) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -548,7 +576,7 @@ static assoc_t onoff[] = { {0, "OFF", NULL}, {1, "ON", NULL}, {-1, "ON", NULL}, int snd_pcm_dump_setup(snd_pcm_t *pcm, int stream, FILE *fp) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_stream_setup_t *setup; if (!pcm) return -EFAULT; diff --git a/src/pcm/pcm_common.c b/src/pcm/pcm_common.c index 8f1ef86c..414b0866 100644 --- a/src/pcm/pcm_common.c +++ b/src/pcm/pcm_common.c @@ -798,10 +798,10 @@ int snd_pcm_plug_format(snd_pcm_plugin_handle_t *handle, } ssize_t snd_pcm_plug_client_channels_buf(snd_pcm_plugin_handle_t *handle, - int stream, - char *buf, - size_t count, - snd_pcm_plugin_channel_t **channels) + int stream, + char *buf, + size_t count, + snd_pcm_plugin_channel_t **channels) { snd_pcm_plugin_t *plugin; snd_pcm_plugin_channel_t *v; @@ -842,10 +842,10 @@ ssize_t snd_pcm_plug_client_channels_buf(snd_pcm_plugin_handle_t *handle, } ssize_t snd_pcm_plug_client_channels_iovec(snd_pcm_plugin_handle_t *handle, - int stream, - const struct iovec *vector, - unsigned long count, - snd_pcm_plugin_channel_t **channels) + int stream, + const struct iovec *vector, + unsigned long count, + snd_pcm_plugin_channel_t **channels) { snd_pcm_plugin_t *plugin; snd_pcm_plugin_channel_t *v; @@ -903,7 +903,7 @@ ssize_t snd_pcm_plug_client_channels_iovec(snd_pcm_plugin_handle_t *handle, } int snd_pcm_plug_playback_channels_mask(snd_pcm_plugin_handle_t *handle, - bitset_t *client_vmask) + bitset_t *client_vmask) { #ifndef __KERNEL__ snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &handle->private; @@ -946,7 +946,7 @@ int snd_pcm_plug_playback_channels_mask(snd_pcm_plugin_handle_t *handle, } int snd_pcm_plug_capture_channels_mask(snd_pcm_plugin_handle_t *handle, - bitset_t *client_vmask) + bitset_t *client_vmask) { #ifndef __KERNEL__ snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &handle->private; @@ -985,7 +985,7 @@ int snd_pcm_plug_capture_channels_mask(snd_pcm_plugin_handle_t *handle, } static int snd_pcm_plug_playback_disable_useless_channels(snd_pcm_plugin_handle_t *handle, - snd_pcm_plugin_channel_t *src_channels) + snd_pcm_plugin_channel_t *src_channels) { snd_pcm_plugin_t *plugin = snd_pcm_plug_first(handle, SND_PCM_STREAM_PLAYBACK); unsigned int nchannels = plugin->src_format.channels; @@ -1010,8 +1010,8 @@ static int snd_pcm_plug_playback_disable_useless_channels(snd_pcm_plugin_handle_ } static int snd_pcm_plug_capture_disable_useless_channels(snd_pcm_plugin_handle_t *handle, - snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *client_channels) + snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *client_channels) { #ifndef __KERNEL__ snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &handle->private; @@ -1158,7 +1158,7 @@ ssize_t snd_pcm_plug_read_transfer(snd_pcm_plugin_handle_t *handle, snd_pcm_plug } int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offset, - size_t samples, int format) + size_t samples, int format) { /* FIXME: sub byte resolution and odd dst_offset */ char *dst; diff --git a/src/pcm/pcm_hw.c b/src/pcm/pcm_hw.c index c8a31c81..a69c4226 100644 --- a/src/pcm/pcm_hw.c +++ b/src/pcm/pcm_hw.c @@ -29,6 +29,17 @@ #include #include "pcm_local.h" +typedef struct { + int fd; +} snd_pcm_hw_stream_t; + +typedef struct snd_pcm_hw { + int card; + int device; + int ver; + snd_pcm_hw_stream_t stream[2]; +} snd_pcm_hw_t; + #define SND_FILE_PCM_PLAYBACK "/dev/snd/pcmC%iD%ip" #define SND_FILE_PCM_CAPTURE "/dev/snd/pcmC%iD%ic" #define SND_PCM_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0) @@ -71,17 +82,10 @@ static int snd_pcm_hw_stream_nonblock(snd_pcm_t *pcm, int stream, int nonblock) return 0; } -static int snd_pcm_hw_info(snd_pcm_t *pcm, snd_pcm_info_t * info) +static int snd_pcm_hw_info(snd_pcm_t *pcm, int stream, snd_pcm_info_t * info) { - int fd, stream; snd_pcm_hw_t *hw = (snd_pcm_hw_t*) &pcm->private; - for (stream = 0; stream < 2; ++stream) { - fd = hw->stream[stream].fd; - if (fd >= 0) - break; - } - if (fd < 0) - return -EBADFD; + int fd = hw->stream[stream].fd; if (ioctl(fd, SND_PCM_IOCTL_INFO, info) < 0) return -errno; return 0; @@ -91,8 +95,6 @@ static int snd_pcm_hw_stream_info(snd_pcm_t *pcm, snd_pcm_stream_info_t * info) { snd_pcm_hw_t *hw = (snd_pcm_hw_t*) &pcm->private; int fd = hw->stream[info->stream].fd; - if (fd < 0) - return -EINVAL; if (ioctl(fd, SND_PCM_IOCTL_STREAM_INFO, info) < 0) return -errno; return 0; @@ -134,13 +136,25 @@ static int snd_pcm_hw_stream_status(snd_pcm_t *pcm, snd_pcm_stream_status_t * st return 0; } -static int snd_pcm_hw_stream_update(snd_pcm_t *pcm, int stream) +static ssize_t snd_pcm_hw_stream_state(snd_pcm_t *pcm, int stream) { snd_pcm_hw_t *hw = (snd_pcm_hw_t*) &pcm->private; int fd = hw->stream[stream].fd; - if (ioctl(fd, SND_PCM_IOCTL_STREAM_UPDATE) < 0) + snd_pcm_stream_status_t status; + status.stream = stream; + if (ioctl(fd, SND_PCM_IOCTL_STREAM_STATUS, status) < 0) return -errno; - return 0; + return status.status; +} + +static ssize_t snd_pcm_hw_stream_byte_io(snd_pcm_t *pcm, int stream, int update UNUSED) +{ + snd_pcm_hw_t *hw = (snd_pcm_hw_t*) &pcm->private; + int fd = hw->stream[stream].fd; + ssize_t pos = ioctl(fd, SND_PCM_IOCTL_STREAM_BYTE_IO); + if (pos < 0) + return -errno; + return pos; } static int snd_pcm_hw_stream_prepare(snd_pcm_t *pcm, int stream) @@ -161,14 +175,10 @@ static int snd_pcm_hw_stream_go(snd_pcm_t *pcm, int stream) return 0; } -static int snd_pcm_hw_sync_go(snd_pcm_t *pcm, snd_pcm_sync_t *sync) +static int snd_pcm_hw_sync_go(snd_pcm_t *pcm, int stream, snd_pcm_sync_t *sync) { snd_pcm_hw_t *hw = (snd_pcm_hw_t*) &pcm->private; - int fd; - if (pcm->stream[SND_PCM_STREAM_PLAYBACK].open) - fd = hw->stream[SND_PCM_STREAM_PLAYBACK].fd; - else - fd = hw->stream[SND_PCM_STREAM_CAPTURE].fd; + int fd = hw->stream[stream].fd; if (ioctl(fd, SND_PCM_IOCTL_SYNC_GO, sync) < 0) return -errno; return 0; @@ -331,7 +341,8 @@ struct snd_pcm_ops snd_pcm_hw_ops = { stream_setup: snd_pcm_hw_stream_setup, channel_setup: snd_pcm_hw_channel_setup, stream_status: snd_pcm_hw_stream_status, - stream_update: snd_pcm_hw_stream_update, + stream_byte_io: snd_pcm_hw_stream_byte_io, + stream_state: snd_pcm_hw_stream_state, stream_prepare: snd_pcm_hw_stream_prepare, stream_go: snd_pcm_hw_stream_go, sync_go: snd_pcm_hw_sync_go, diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h index df0df826..51fb11bc 100644 --- a/src/pcm/pcm_local.h +++ b/src/pcm/pcm_local.h @@ -22,23 +22,23 @@ #include #include "asoundlib.h" - struct snd_pcm_ops { int (*stream_close)(snd_pcm_t *pcm, int stream); int (*stream_nonblock)(snd_pcm_t *pcm, int stream, int nonblock); - int (*info)(snd_pcm_t *pcm, snd_pcm_info_t *info); + int (*info)(snd_pcm_t *pcm, int stream, snd_pcm_info_t *info); int (*stream_info)(snd_pcm_t *pcm, snd_pcm_stream_info_t *info); int (*stream_params)(snd_pcm_t *pcm, snd_pcm_stream_params_t *params); int (*stream_setup)(snd_pcm_t *pcm, snd_pcm_stream_setup_t *setup); int (*channel_setup)(snd_pcm_t *pcm, int stream, snd_pcm_channel_setup_t *setup); int (*stream_status)(snd_pcm_t *pcm, snd_pcm_stream_status_t *status); int (*stream_prepare)(snd_pcm_t *pcm, int stream); - int (*stream_update)(snd_pcm_t *pcm, int stream); int (*stream_go)(snd_pcm_t *pcm, int stream); - int (*sync_go)(snd_pcm_t *pcm, snd_pcm_sync_t *sync); + int (*sync_go)(snd_pcm_t *pcm, int stream, snd_pcm_sync_t *sync); int (*stream_drain)(snd_pcm_t *pcm, int stream); int (*stream_flush)(snd_pcm_t *pcm, int stream); int (*stream_pause)(snd_pcm_t *pcm, int stream, int enable); + int (*stream_state)(snd_pcm_t *pcm, int stream); + ssize_t (*stream_byte_io)(snd_pcm_t *pcm, int stream, int update); ssize_t (*stream_seek)(snd_pcm_t *pcm, int stream, off_t offset); ssize_t (*write)(snd_pcm_t *pcm, const void *buffer, size_t size); ssize_t (*writev)(snd_pcm_t *pcm, const struct iovec *vector, unsigned long count); @@ -52,33 +52,21 @@ struct snd_pcm_ops { int (*channels_mask)(snd_pcm_t *pcm, int stream, bitset_t *client_vmask); }; - -struct snd_pcm_plug_stream { +typedef struct { snd_pcm_plugin_t *first; snd_pcm_plugin_t *last; void *alloc_ptr[2]; size_t alloc_size[2]; int alloc_lock[2]; -}; +} snd_pcm_plug_stream_t; -typedef struct snd_pcm_plug { +typedef struct { int close_slave; snd_pcm_t *slave; - struct snd_pcm_plug_stream stream[2]; + snd_pcm_plug_stream_t stream[2]; } snd_pcm_plug_t; -struct snd_pcm_hw_stream { - int fd; -}; - -typedef struct snd_pcm_hw { - int card; - int device; - int ver; - struct snd_pcm_hw_stream stream[2]; -} snd_pcm_hw_t; - -struct snd_pcm_stream { +typedef struct { int open; int mode; int valid_setup; @@ -91,13 +79,13 @@ struct snd_pcm_stream { size_t mmap_control_size; char *mmap_data; size_t mmap_data_size; -}; +} snd_pcm_stream_t; struct snd_pcm { snd_pcm_type_t type; int mode; struct snd_pcm_ops *ops; - struct snd_pcm_stream stream[2]; + snd_pcm_stream_t stream[2]; int private[0]; }; @@ -142,3 +130,22 @@ int conv_index(int src_format, int dst_format); #else #define pdprintf( args... ) { ; } #endif + +static inline ssize_t snd_pcm_mmap_playback_bytes_used(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; +} + +static inline size_t snd_pcm_mmap_capture_bytes_used(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; +} + diff --git a/src/pcm/pcm_mmap.c b/src/pcm/pcm_mmap.c index 73e330b6..0efb34f4 100644 --- a/src/pcm/pcm_mmap.c +++ b/src/pcm/pcm_mmap.c @@ -26,41 +26,23 @@ #include #include "pcm_local.h" -static inline ssize_t snd_pcm_mmap_playback_bytes_used(struct snd_pcm_stream *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; -} - static ssize_t snd_pcm_mmap_playback_frames_used(snd_pcm_t *pcm) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; ssize_t bytes = snd_pcm_mmap_playback_bytes_used(str); return bytes * 8 / str->bits_per_frame; } -static inline size_t snd_pcm_mmap_capture_bytes_used(struct snd_pcm_stream *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; -} - static size_t snd_pcm_mmap_capture_frames_used(snd_pcm_t *pcm) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; size_t bytes = snd_pcm_mmap_capture_bytes_used(str); return bytes * 8 / str->bits_per_frame; } int snd_pcm_mmap_frames_used(snd_pcm_t *pcm, int stream, ssize_t *frames) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -75,33 +57,33 @@ int snd_pcm_mmap_frames_used(snd_pcm_t *pcm, int stream, ssize_t *frames) return 0; } -static inline size_t snd_pcm_mmap_playback_bytes_free(struct snd_pcm_stream *str) +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) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; + 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(struct snd_pcm_stream *str) +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) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; + 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) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -118,7 +100,7 @@ int snd_pcm_mmap_frames_free(snd_pcm_t *pcm, int stream, ssize_t *frames) static int snd_pcm_mmap_playback_ready(snd_pcm_t *pcm) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; if (str->mmap_control->status == SND_PCM_STATUS_XRUN) return -EPIPE; @@ -127,7 +109,7 @@ static int snd_pcm_mmap_playback_ready(snd_pcm_t *pcm) static int snd_pcm_mmap_capture_ready(snd_pcm_t *pcm) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; int ret = 0; str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; if (str->mmap_control->status == SND_PCM_STATUS_XRUN) { @@ -142,7 +124,7 @@ static int snd_pcm_mmap_capture_ready(snd_pcm_t *pcm) int snd_pcm_mmap_ready(snd_pcm_t *pcm, int stream) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_mmap_control_t *ctrl; if (!pcm) return -EFAULT; @@ -163,7 +145,7 @@ int snd_pcm_mmap_ready(snd_pcm_t *pcm, int stream) static size_t snd_pcm_mmap_playback_bytes_xfer(snd_pcm_t *pcm, size_t bytes) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; + 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; @@ -179,7 +161,7 @@ static size_t snd_pcm_mmap_playback_bytes_xfer(snd_pcm_t *pcm, size_t bytes) static size_t snd_pcm_mmap_capture_bytes_xfer(snd_pcm_t *pcm, size_t bytes) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; + 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; @@ -195,7 +177,7 @@ static size_t snd_pcm_mmap_capture_bytes_xfer(snd_pcm_t *pcm, size_t bytes) static ssize_t snd_pcm_mmap_playback_frames_xfer(snd_pcm_t *pcm, size_t frames) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; size_t bytes = frames * str->bits_per_frame / 8; bytes = snd_pcm_mmap_playback_bytes_xfer(pcm, bytes); return bytes * 8 / str->bits_per_frame; @@ -203,7 +185,7 @@ static ssize_t snd_pcm_mmap_playback_frames_xfer(snd_pcm_t *pcm, size_t frames) static ssize_t snd_pcm_mmap_capture_frames_xfer(snd_pcm_t *pcm, size_t frames) { - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; size_t bytes = frames * str->bits_per_frame / 8; bytes = snd_pcm_mmap_capture_bytes_xfer(pcm, bytes); return bytes * 8 / str->bits_per_frame; @@ -211,7 +193,7 @@ static ssize_t snd_pcm_mmap_capture_frames_xfer(snd_pcm_t *pcm, size_t frames) ssize_t snd_pcm_mmap_frames_xfer(snd_pcm_t *pcm, int stream, size_t frames) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -227,7 +209,7 @@ 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) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_mmap_control_t *ctrl; if (!pcm) return -EFAULT; @@ -244,7 +226,7 @@ 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) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_mmap_control_t *ctrl; size_t byte_data, bytes; if (!pcm) @@ -272,7 +254,7 @@ 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) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_mmap_control_t *ctrl; size_t offset = 0; size_t result = 0; @@ -288,7 +270,7 @@ ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channel } else { if (ctrl->status == SND_PCM_STATUS_RUNNING && str->mode & SND_PCM_NONBLOCK) - snd_pcm_stream_update(pcm, SND_PCM_STREAM_PLAYBACK); + snd_pcm_stream_byte_io(pcm, SND_PCM_STREAM_PLAYBACK, 1); } while (frames > 0) { ssize_t mmap_offset; @@ -335,7 +317,7 @@ ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channel ssize_t snd_pcm_mmap_write_frames(snd_pcm_t *pcm, const void *buffer, size_t frames) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; unsigned int nchannels; if (!pcm) return -EFAULT; @@ -363,7 +345,7 @@ ssize_t snd_pcm_mmap_write_frames(snd_pcm_t *pcm, const void *buffer, size_t fra ssize_t snd_pcm_mmap_write(snd_pcm_t *pcm, const void *buffer, size_t bytes) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; unsigned int nchannels; ssize_t frames; if (!pcm) @@ -387,7 +369,7 @@ ssize_t snd_pcm_mmap_write(snd_pcm_t *pcm, const void *buffer, size_t bytes) ssize_t snd_pcm_mmap_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned long vcount) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; size_t result = 0; unsigned int nchannels; if (!pcm) @@ -451,7 +433,7 @@ ssize_t snd_pcm_mmap_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels, size_t frames) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_mmap_control_t *ctrl; size_t offset = 0; size_t result = 0; @@ -467,7 +449,7 @@ ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels } else { if (ctrl->status == SND_PCM_STATUS_RUNNING && str->mode & SND_PCM_NONBLOCK) - snd_pcm_stream_update(pcm, SND_PCM_STREAM_CAPTURE); + snd_pcm_stream_byte_io(pcm, SND_PCM_STREAM_CAPTURE, 1); } if (ctrl->status == SND_PCM_STATUS_PREPARED && str->setup.start_mode == SND_PCM_START_DATA) { @@ -513,7 +495,7 @@ ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels ssize_t snd_pcm_mmap_read_frames(snd_pcm_t *pcm, const void *buffer, size_t frames) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; unsigned int nchannels; if (!pcm) return -EFAULT; @@ -541,7 +523,7 @@ ssize_t snd_pcm_mmap_read_frames(snd_pcm_t *pcm, const void *buffer, size_t fram ssize_t snd_pcm_mmap_read(snd_pcm_t *pcm, void *buffer, size_t bytes) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; unsigned int nchannels; ssize_t frames; if (!pcm) @@ -565,7 +547,7 @@ ssize_t snd_pcm_mmap_read(snd_pcm_t *pcm, void *buffer, size_t bytes) ssize_t snd_pcm_mmap_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned long vcount) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; size_t result = 0; unsigned int nchannels; if (!pcm) @@ -627,7 +609,7 @@ 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(struct snd_pcm_stream *str) +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; @@ -640,7 +622,7 @@ static ssize_t mmap_playback_bytes_xfer(struct snd_pcm_stream *str) return bytes; } -static ssize_t mmap_capture_bytes_xfer(struct snd_pcm_stream *str) +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; @@ -655,7 +637,7 @@ static ssize_t mmap_capture_bytes_xfer(struct snd_pcm_stream *str) int snd_pcm_mmap_control(snd_pcm_t *pcm, int stream, snd_pcm_mmap_control_t **control) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_stream_info_t info; size_t csize; int err; @@ -683,7 +665,7 @@ int snd_pcm_mmap_control(snd_pcm_t *pcm, int stream, snd_pcm_mmap_control_t **co int snd_pcm_mmap_get_areas(snd_pcm_t *pcm, int stream, snd_pcm_channel_area_t *areas) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_channel_setup_t s; snd_pcm_channel_area_t *a, *ap; unsigned int channel; @@ -713,7 +695,7 @@ int snd_pcm_mmap_get_areas(snd_pcm_t *pcm, int stream, snd_pcm_channel_area_t *a int snd_pcm_mmap_data(snd_pcm_t *pcm, int stream, void **data) { - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; snd_pcm_stream_info_t info; size_t bsize; int err; @@ -765,7 +747,7 @@ int snd_pcm_mmap(snd_pcm_t *pcm, int stream, snd_pcm_mmap_control_t **control, v int snd_pcm_munmap_control(snd_pcm_t *pcm, int stream) { int err; - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -785,7 +767,7 @@ int snd_pcm_munmap_control(snd_pcm_t *pcm, int stream) int snd_pcm_munmap_data(snd_pcm_t *pcm, int stream) { int err; - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) diff --git a/src/pcm/pcm_plug.c b/src/pcm/pcm_plug.c index a0a0c327..7b04caaa 100644 --- a/src/pcm/pcm_plug.c +++ b/src/pcm/pcm_plug.c @@ -34,7 +34,7 @@ void *snd_pcm_plug_buf_alloc(snd_pcm_t *pcm, int stream, size_t size) { int idx; snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; - struct snd_pcm_plug_stream *plugstr = &plug->stream[stream]; + snd_pcm_plug_stream_t *plugstr = &plug->stream[stream]; for (idx = 0; idx < 2; idx++) { if (plugstr->alloc_lock[idx]) @@ -64,7 +64,7 @@ void snd_pcm_plug_buf_unlock(snd_pcm_t *pcm, int stream, void *ptr) int idx; snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; if (!ptr) return; @@ -84,7 +84,7 @@ void snd_pcm_plug_buf_unlock(snd_pcm_t *pcm, int stream, void *ptr) int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin) { snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; snd_pcm_t *pcm; if (!plugin) return -EFAULT; @@ -106,7 +106,7 @@ int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin) int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin) { snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; snd_pcm_t *pcm; if (!plugin) return -EFAULT; @@ -132,7 +132,7 @@ int snd_pcm_plugin_remove_to(snd_pcm_plugin_t *plugin) snd_pcm_plugin_t *plugin1, *plugin1_prev; snd_pcm_plug_t *plug; snd_pcm_t *pcm; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; if (!plugin) return -EFAULT; pcm = plugin->handle; @@ -160,7 +160,7 @@ int snd_pcm_plug_remove_first(snd_pcm_t *pcm, int stream) { snd_pcm_plugin_t *plugin; snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; if (!pcm) return -EFAULT; if (stream < 0 || stream > 1) @@ -187,7 +187,7 @@ int snd_pcm_plug_clear(snd_pcm_t *pcm, int stream) { snd_pcm_plugin_t *plugin, *plugin_next; snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; int idx; if (!pcm) @@ -221,7 +221,7 @@ int snd_pcm_plug_clear(snd_pcm_t *pcm, int stream) snd_pcm_plugin_t *snd_pcm_plug_first(snd_pcm_t *pcm, int stream) { snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; if (!pcm) return NULL; if (stream < 0 || stream > 1) @@ -238,7 +238,7 @@ snd_pcm_plugin_t *snd_pcm_plug_first(snd_pcm_t *pcm, int stream) snd_pcm_plugin_t *snd_pcm_plug_last(snd_pcm_t *pcm, int stream) { snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; if (!pcm) return NULL; if (stream < 0 || stream > 1) @@ -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, snd_pcm_info_t * info) +static int snd_pcm_plug_info(snd_pcm_t *pcm, int stream, snd_pcm_info_t * info) { snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; return snd_pcm_info(plug->slave, info); @@ -320,7 +320,7 @@ static int snd_pcm_plug_stream_info(snd_pcm_t *pcm, snd_pcm_stream_info_t *info) { int err; snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; - struct snd_pcm_stream *str; + snd_pcm_stream_t *str; if ((err = snd_pcm_stream_info(plug->slave, info)) < 0) return err; @@ -356,7 +356,7 @@ static int snd_pcm_plug_action(snd_pcm_t *pcm, int stream, int action, snd_pcm_plugin_t *plugin; int err; snd_pcm_plug_t *plug; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; plug = (snd_pcm_plug_t*) &pcm->private; plugstr = &plug->stream[stream]; @@ -407,6 +407,21 @@ static int snd_pcm_plug_stream_params(snd_pcm_t *pcm, snd_pcm_stream_params_t *p if (snd_pcm_plug_direct(pcm, stream)) return snd_pcm_stream_params(plug->slave, params); + /* compute right sizes */ + slave_params.frag_size = snd_pcm_plug_slave_size(pcm, stream, params->frag_size); + slave_params.buffer_size = snd_pcm_plug_slave_size(pcm, stream, params->buffer_size); + slave_params.bytes_fill_max = snd_pcm_plug_slave_size(pcm, stream, params->bytes_fill_max); + slave_params.bytes_min = snd_pcm_plug_slave_size(pcm, stream, params->bytes_min); + slave_params.bytes_xrun_max = snd_pcm_plug_slave_size(pcm, stream, params->bytes_xrun_max); + slave_params.bytes_align = snd_pcm_plug_slave_size(pcm, stream, params->bytes_align); + if (slave_params.byte_boundary == 0 || slave_params.byte_boundary > INT_MAX) + slave_params.byte_boundary = INT_MAX; + slave_params.byte_boundary /= params->buffer_size; + if (slave_params.byte_boundary > INT_MAX / slave_params.buffer_size) + slave_params.byte_boundary = INT_MAX; + else + slave_params.byte_boundary *= slave_params.buffer_size; + /* * I/O plugins */ @@ -430,14 +445,6 @@ static int snd_pcm_plug_stream_params(snd_pcm_t *pcm, snd_pcm_stream_params_t *p return err; } - /* compute right sizes */ - slave_params.buffer_size = snd_pcm_plug_slave_size(pcm, stream, slave_params.buffer_size); - slave_params.frag_size = snd_pcm_plug_slave_size(pcm, stream, slave_params.frag_size); - slave_params.bytes_fill_max = snd_pcm_plug_slave_size(pcm, stream, slave_params.bytes_fill_max); - slave_params.bytes_min = snd_pcm_plug_slave_size(pcm, stream, slave_params.bytes_min); - slave_params.bytes_xrun_max = snd_pcm_plug_slave_size(pcm, stream, slave_params.bytes_xrun_max); - slave_params.bytes_align = snd_pcm_plug_slave_size(pcm, stream, slave_params.bytes_align); - pdprintf("params requested params: format = %i, rate = %i, channels = %i\n", slave_params.format.format, slave_params.format.rate, slave_params.format.channels); err = snd_pcm_stream_params(plug->slave, &slave_params); if (err < 0) @@ -453,7 +460,7 @@ static int snd_pcm_plug_stream_setup(snd_pcm_t *pcm, snd_pcm_stream_setup_t *set { int err; snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; - struct snd_pcm_plug_stream *plugstr; + snd_pcm_plug_stream_t *plugstr; err = snd_pcm_stream_setup(plug->slave, setup); if (err < 0) @@ -488,28 +495,23 @@ static int snd_pcm_plug_stream_status(snd_pcm_t *pcm, snd_pcm_stream_status_t *s if (snd_pcm_plug_direct(pcm, status->stream)) return 0; - /* FIXME: may overflow */ status->byte_io = snd_pcm_plug_client_size(pcm, status->stream, status->byte_io); status->byte_data = snd_pcm_plug_client_size(pcm, status->stream, status->byte_data); - status->bytes_used = snd_pcm_plug_client_size(pcm, status->stream, status->bytes_used); + status->bytes_avail = snd_pcm_plug_client_size(pcm, status->stream, status->bytes_avail); + status->bytes_avail_max = snd_pcm_plug_client_size(pcm, status->stream, status->bytes_avail_max); return 0; } -static int snd_pcm_plug_stream_update(snd_pcm_t *pcm, int stream) +static int snd_pcm_plug_stream_state(snd_pcm_t *pcm, int stream) { snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; - int err; - err = snd_pcm_stream_update(plug->slave, stream); - if (err < 0) - return err; - if (snd_pcm_plug_direct(pcm, stream)) - return 0; -#if 0 - /* To think more about that */ - if ((err = snd_pcm_plug_action(pcm, stream, UPDATE, 0))<0) - return err; -#endif - return 0; + return snd_pcm_stream_state(plug->slave, stream); +} + +static int snd_pcm_plug_stream_byte_io(snd_pcm_t *pcm, int stream, int update) +{ + snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; + return snd_pcm_stream_byte_io(plug->slave, stream, update); } static int snd_pcm_plug_stream_prepare(snd_pcm_t *pcm, int stream) @@ -532,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, snd_pcm_sync_t *sync) +static int snd_pcm_plug_sync_go(snd_pcm_t *pcm, int stream, snd_pcm_sync_t *sync) { snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; return snd_pcm_sync_go(plug->slave, sync); @@ -581,35 +583,11 @@ static int snd_pcm_plug_stream_pause(snd_pcm_t *pcm, int stream, int enable) static int snd_pcm_plug_channel_setup(snd_pcm_t *pcm, int stream, snd_pcm_channel_setup_t *setup) { snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; - struct snd_pcm_stream *str; - unsigned int channel; - int width; if (snd_pcm_plug_direct(pcm, stream)) return snd_pcm_channel_setup(plug->slave, stream, setup); - - channel = setup->channel; - memset(setup, 0, sizeof(*setup)); - setup->channel = channel; - str = &pcm->stream[stream]; - if (!str->mmap_data) { - setup->area.addr = 0; - return 0; - } - if (channel >= str->setup.format.channels) - return -EINVAL; - - if (str->setup.format.interleave) { - setup->area.addr = str->mmap_data; - setup->area.first = setup->channel * str->sample_width; - setup->area.step = str->bits_per_frame; - } else { - size_t size = str->mmap_data_size / str->setup.format.channels; - setup->area.addr = str->mmap_data + setup->channel * size; - setup->area.first = 0; - setup->area.step = str->sample_width; - } - return 0; + /* FIXME: non mmap setups */ + return -ENXIO; } static ssize_t snd_pcm_plug_stream_seek(snd_pcm_t *pcm, int stream, off_t offset) @@ -637,7 +615,7 @@ static ssize_t snd_pcm_plug_stream_seek(snd_pcm_t *pcm, int stream, off_t offset ssize_t snd_pcm_plug_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned long count) { snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_PLAYBACK]; unsigned int k, step, channels; int size = 0; if (snd_pcm_plug_direct(pcm, SND_PCM_STREAM_PLAYBACK)) @@ -672,7 +650,7 @@ ssize_t snd_pcm_plug_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned ssize_t snd_pcm_plug_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned long count) { snd_pcm_plug_t *plug = (snd_pcm_plug_t*) &pcm->private; - struct snd_pcm_stream *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; + snd_pcm_stream_t *str = &pcm->stream[SND_PCM_STREAM_CAPTURE]; unsigned int k, step, channels; int size = 0; if (snd_pcm_plug_direct(pcm, SND_PCM_STREAM_CAPTURE)) @@ -791,7 +769,8 @@ struct snd_pcm_ops snd_pcm_plug_ops = { stream_setup: snd_pcm_plug_stream_setup, channel_setup: snd_pcm_plug_channel_setup, stream_status: snd_pcm_plug_stream_status, - stream_update: snd_pcm_plug_stream_update, + stream_byte_io: snd_pcm_plug_stream_byte_io, + stream_state: snd_pcm_plug_stream_state, stream_prepare: snd_pcm_plug_stream_prepare, stream_go: snd_pcm_plug_stream_go, sync_go: snd_pcm_plug_sync_go, diff --git a/src/pcm/plugin/mmap.c b/src/pcm/plugin/mmap.c index 7e54327b..4372b73b 100644 --- a/src/pcm/plugin/mmap.c +++ b/src/pcm/plugin/mmap.c @@ -50,7 +50,7 @@ static ssize_t mmap_src_channels(snd_pcm_plugin_t *plugin, mmap_t *data; snd_pcm_plugin_channel_t *sv; snd_pcm_channel_area_t *dv; - struct snd_pcm_stream *stream; + snd_pcm_stream_t *stream; snd_pcm_stream_setup_t *setup; snd_pcm_mmap_control_t *ctrl; size_t pos; @@ -119,7 +119,7 @@ static ssize_t mmap_dst_channels(snd_pcm_plugin_t *plugin, unsigned int channel; snd_pcm_plugin_channel_t *dv; snd_pcm_channel_area_t *sv; - struct snd_pcm_stream *stream; + snd_pcm_stream_t *stream; snd_pcm_stream_setup_t *setup; snd_pcm_mmap_control_t *ctrl; size_t pos; @@ -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; - struct snd_pcm_stream *stream; + snd_pcm_stream_t *stream; int err; if (plugin == NULL) -- 2.47.1