mirrors/alsa-lib
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-lib.git synced 2025-10-29 05:40:25 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added snd_pcm_stream_state and snd_pcm_stream_byte_io. Added needed callbacks and cleaned some existing. Fixed byte_boundary request

Browse source
This commit is contained in:
Abramo Bagnara 2000-06-01 21:58:25 +00:00
parent 2ff2c87cdb
commit f11e203d6e
9 changed files with 216 additions and 208 deletions
Download patch file Download diff file Expand all files Collapse all files

5
include/pcm.h
View file

@ -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);

4
src/pcm/Makefile.am
View file

@ -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

76
src/pcm/pcm.c
View file

@ -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;
return pcm->ops->stream_update(pcm, stream);
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;
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;

28
src/pcm/pcm_common.c
View file

@ -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;

53
src/pcm/pcm_hw.c
View file

@ -29,6 +29,17 @@
#include <sys/mman.h>
#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,

53
src/pcm/pcm_local.h
View file

@ -22,23 +22,23 @@
#include <pthread.h>
#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;
}

88
src/pcm/pcm_mmap.c
View file

@ -26,41 +26,23 @@
#include <sys/uio.h>
#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)

111
src/pcm/pcm_plug.c
View file

@ -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,

6
src/pcm/plugin/mmap.c
View file

@ -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)