From: Abramo Bagnara Date: Fri, 20 Oct 2000 14:03:44 +0000 (+0000) Subject: Remove channels_mask. Implemented pcm_null X-Git-Tag: v1.0.3~1090 X-Git-Url: https://git.alsa-project.org/?a=commitdiff_plain;h=dba8c25e3c8256cb11983ecea4e07ff6e182ce6e;p=alsa-lib.git Remove channels_mask. Implemented pcm_null --- diff --git a/src/pcm/Makefile.am b/src/pcm/Makefile.am index 30baaf18..f59b6bb2 100644 --- a/src/pcm/Makefile.am +++ b/src/pcm/Makefile.am @@ -4,7 +4,7 @@ EXTRA_LTLIBRARIES = libpcm.la libpcm_la_SOURCES = pcm.c pcm_hw.c pcm_plugin.c pcm_linear.c pcm_route.c \ pcm_mulaw.c pcm_alaw.c pcm_adpcm.c pcm_rate.c pcm_plug.c \ pcm_misc.c pcm_mmap.c pcm_multi.c pcm_shm.c pcm_file.c \ - pcm_share.c + pcm_share.c pcm_null.c noinst_HEADERS = pcm_local.h pcm_plugin.h all: libpcm.la diff --git a/src/pcm/pcm.c b/src/pcm/pcm.c index 7e6f1df9..36299263 100644 --- a/src/pcm/pcm.c +++ b/src/pcm/pcm.c @@ -203,6 +203,8 @@ int snd_pcm_start(snd_pcm_t *pcm) { assert(pcm); assert(pcm->valid_setup); + assert(pcm->stream != SND_PCM_STREAM_PLAYBACK || + snd_pcm_mmap_avail(pcm) > 0); return pcm->fast_ops->start(pcm->fast_op_arg); } @@ -359,13 +361,6 @@ int snd_pcm_poll_descriptor(snd_pcm_t *pcm) return pcm->poll_fd; } -int snd_pcm_channels_mask(snd_pcm_t *pcm, bitset_t *cmask) -{ - assert(pcm); - assert(pcm->valid_setup); - return pcm->fast_ops->channels_mask(pcm->fast_op_arg, cmask); -} - typedef struct { int value; const char* name; diff --git a/src/pcm/pcm_file.c b/src/pcm/pcm_file.c index 1f25bcfe..192bccc6 100644 --- a/src/pcm/pcm_file.c +++ b/src/pcm/pcm_file.c @@ -244,7 +244,7 @@ static ssize_t snd_pcm_file_avail_update(snd_pcm_t *pcm) return snd_pcm_avail_update(file->slave); } -int snd_pcm_file_set_avail_min(snd_pcm_t *pcm, size_t frames) +static int snd_pcm_file_set_avail_min(snd_pcm_t *pcm, size_t frames) { snd_pcm_file_t *file = pcm->private; return snd_pcm_set_avail_min(file->slave, frames); @@ -272,12 +272,6 @@ static int snd_pcm_file_munmap(snd_pcm_t *pcm) return 0; } -static int snd_pcm_file_channels_mask(snd_pcm_t *pcm, bitset_t *cmask) -{ - snd_pcm_file_t *file = pcm->private; - return snd_pcm_channels_mask(file->slave, cmask); -} - static int snd_pcm_file_params_info(snd_pcm_t *pcm, snd_pcm_params_info_t * info) { snd_pcm_file_t *file = pcm->private; @@ -341,7 +335,6 @@ snd_pcm_fast_ops_t snd_pcm_file_fast_ops = { writen: snd_pcm_file_writen, readi: snd_pcm_file_readi, readn: snd_pcm_file_readn, - channels_mask: snd_pcm_file_channels_mask, avail_update: snd_pcm_file_avail_update, mmap_forward: snd_pcm_file_mmap_forward, set_avail_min: snd_pcm_file_set_avail_min, diff --git a/src/pcm/pcm_hw.c b/src/pcm/pcm_hw.c index 0c290cf3..fb6356b1 100644 --- a/src/pcm/pcm_hw.c +++ b/src/pcm/pcm_hw.c @@ -502,12 +502,6 @@ static int snd_pcm_hw_set_avail_min(snd_pcm_t *pcm, size_t frames) return 0; } -static int snd_pcm_hw_channels_mask(snd_pcm_t *pcm ATTRIBUTE_UNUSED, - bitset_t *cmask ATTRIBUTE_UNUSED) -{ - return 0; -} - static void snd_pcm_hw_dump(snd_pcm_t *pcm, FILE *fp) { snd_pcm_hw_t *hw = pcm->private; @@ -552,7 +546,6 @@ snd_pcm_fast_ops_t snd_pcm_hw_fast_ops = { writen: snd_pcm_hw_writen, readi: snd_pcm_hw_readi, readn: snd_pcm_hw_readn, - channels_mask: snd_pcm_hw_channels_mask, avail_update: snd_pcm_hw_avail_update, mmap_forward: snd_pcm_hw_mmap_forward, set_avail_min: snd_pcm_hw_set_avail_min, diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h index a649251c..8d70ace1 100644 --- a/src/pcm/pcm_local.h +++ b/src/pcm/pcm_local.h @@ -64,7 +64,6 @@ typedef struct { ssize_t (*writen)(snd_pcm_t *pcm, void **bufs, size_t size); ssize_t (*readi)(snd_pcm_t *pcm, void *buffer, size_t size); ssize_t (*readn)(snd_pcm_t *pcm, void **bufs, size_t size); - int (*channels_mask)(snd_pcm_t *pcm, bitset_t *cmask); ssize_t (*avail_update)(snd_pcm_t *pcm); ssize_t (*mmap_forward)(snd_pcm_t *pcm, size_t size); int (*set_avail_min)(snd_pcm_t *pcm, size_t frames); diff --git a/src/pcm/pcm_multi.c b/src/pcm/pcm_multi.c index d22929bf..13c9f523 100644 --- a/src/pcm/pcm_multi.c +++ b/src/pcm/pcm_multi.c @@ -407,49 +407,12 @@ static ssize_t snd_pcm_multi_mmap_forward(snd_pcm_t *pcm, size_t size) return size; } -int snd_pcm_multi_set_avail_min(snd_pcm_t *pcm, size_t frames) +static int snd_pcm_multi_set_avail_min(snd_pcm_t *pcm, size_t frames) { snd_pcm_multi_t *multi = pcm->private; return snd_pcm_set_avail_min(multi->slaves[0].pcm, frames); } -static int snd_pcm_multi_channels_mask(snd_pcm_t *pcm, bitset_t *cmask) -{ - snd_pcm_multi_t *multi = pcm->private; - unsigned int i; - bitset_t *cmasks[multi->slaves_count]; - int err; - for (i = 0; i < multi->slaves_count; ++i) - cmasks[i] = bitset_alloc(multi->slaves[i].channels_count); - for (i = 0; i < multi->channels_count; ++i) { - snd_pcm_multi_channel_t *b = &multi->channels[i]; - if (b->slave_idx < 0) - continue; - if (bitset_get(cmask, i)) - bitset_set(cmasks[b->slave_idx], b->slave_channel); - } - for (i = 0; i < multi->slaves_count; ++i) { - snd_pcm_t *slave = multi->slaves[i].pcm; - err = snd_pcm_channels_mask(slave, cmasks[i]); - if (err < 0) { - for (i = 0; i <= multi->slaves_count; ++i) - free(cmasks[i]); - return err; - } - } - bitset_zero(cmask, pcm->setup.format.channels); - for (i = 0; i < multi->channels_count; ++i) { - snd_pcm_multi_channel_t *b = &multi->channels[i]; - if (b->slave_idx < 0) - continue; - if (bitset_get(cmasks[b->slave_idx], b->slave_channel)) - bitset_set(cmask, i); - } - for (i = 0; i < multi->slaves_count; ++i) - free(cmasks[i]); - return 0; -} - int snd_pcm_multi_poll_descriptor(snd_pcm_t *pcm) { snd_pcm_multi_t *multi = pcm->private; @@ -510,7 +473,6 @@ snd_pcm_fast_ops_t snd_pcm_multi_fast_ops = { readi: snd_pcm_mmap_readi, readn: snd_pcm_mmap_readn, rewind: snd_pcm_multi_rewind, - channels_mask: snd_pcm_multi_channels_mask, avail_update: snd_pcm_multi_avail_update, mmap_forward: snd_pcm_multi_mmap_forward, set_avail_min: snd_pcm_multi_set_avail_min, diff --git a/src/pcm/pcm_null.c b/src/pcm/pcm_null.c new file mode 100644 index 00000000..625c08f9 --- /dev/null +++ b/src/pcm/pcm_null.c @@ -0,0 +1,442 @@ +/* + * PCM - Null plugin + * Copyright (c) 2000 by Abramo Bagnara + * + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include +#include +#include "pcm_local.h" +#include "pcm_plugin.h" + +typedef struct { + snd_pcm_setup_t setup; + snd_timestamp_t trigger_time; + int state; + size_t appl_ptr; + size_t hw_ptr; + int poll_fd; +} snd_pcm_null_t; + +static int snd_pcm_null_close(snd_pcm_t *pcm) +{ + snd_pcm_null_t *null = pcm->private; + close(null->poll_fd); + free(null); + return 0; +} + +static int snd_pcm_null_nonblock(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int nonblock ATTRIBUTE_UNUSED) +{ + return 0; +} + +static int snd_pcm_null_async(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int sig ATTRIBUTE_UNUSED, pid_t pid ATTRIBUTE_UNUSED) +{ + return -ENOSYS; +} + +static int snd_pcm_null_info(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_info_t * info) +{ + memset(info, 0, sizeof(*info)); + /* FIXME */ + return 0; +} + +static int snd_pcm_null_channel_info(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_channel_info_t * info) +{ + int channel = info->channel; + memset(info, 0, sizeof(*info)); + info->channel = channel; + return 0; +} + +static int snd_pcm_null_channel_params(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_channel_params_t * params ATTRIBUTE_UNUSED) +{ + return 0; +} + +static int snd_pcm_null_channel_setup(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_channel_setup_t * setup) +{ + int channel = setup->channel; + memset(setup, 0, sizeof(*setup)); + setup->channel = channel; + return 0; +} + +static int snd_pcm_null_status(snd_pcm_t *pcm, snd_pcm_status_t * status) +{ + snd_pcm_null_t *null = pcm->private; + memset(status, 0, sizeof(*status)); + status->state = null->state; + status->trigger_time = null->trigger_time; + gettimeofday(&status->tstamp, 0); + status->avail = pcm->setup.buffer_size; + status->avail_max = status->avail; + return 0; +} + +static int snd_pcm_null_state(snd_pcm_t *pcm) +{ + snd_pcm_null_t *null = pcm->private; + return null->state; +} + +static int snd_pcm_null_delay(snd_pcm_t *pcm ATTRIBUTE_UNUSED, ssize_t *delayp) +{ + *delayp = 0; + return 0; +} + +static int snd_pcm_null_prepare(snd_pcm_t *pcm) +{ + snd_pcm_null_t *null = pcm->private; + null->state = SND_PCM_STATE_PREPARED; + null->appl_ptr = 0; + null->hw_ptr = 0; + return 0; +} + +static int snd_pcm_null_start(snd_pcm_t *pcm) +{ + snd_pcm_null_t *null = pcm->private; + assert(null->state == SND_PCM_STATE_PREPARED); + null->state = SND_PCM_STATE_RUNNING; + if (pcm->stream == SND_PCM_STREAM_CAPTURE) + snd_pcm_mmap_appl_forward(pcm, pcm->setup.buffer_size); + return 0; +} + +static int snd_pcm_null_drop(snd_pcm_t *pcm) +{ + snd_pcm_null_t *null = pcm->private; + assert(null->state != SND_PCM_STATE_OPEN); + null->state = SND_PCM_STATE_SETUP; + return 0; +} + +static int snd_pcm_null_drain(snd_pcm_t *pcm) +{ + snd_pcm_null_t *null = pcm->private; + assert(null->state != SND_PCM_STATE_OPEN); + null->state = SND_PCM_STATE_SETUP; + return 0; +} + +static int snd_pcm_null_pause(snd_pcm_t *pcm, int enable) +{ + snd_pcm_null_t *null = pcm->private; + if (enable) { + if (null->state != SND_PCM_STATE_RUNNING) + return -EBADFD; + } else if (null->state != SND_PCM_STATE_PAUSED) + return -EBADFD; + null->state = SND_PCM_STATE_PAUSED; + return 0; +} + +static ssize_t snd_pcm_null_rewind(snd_pcm_t *pcm, size_t frames) +{ + snd_pcm_null_t *null = pcm->private; + switch (null->state) { + case SND_PCM_STATE_PREPARED: + case SND_PCM_STATE_RUNNING: + snd_pcm_mmap_appl_backward(pcm, frames); + snd_pcm_mmap_hw_backward(pcm, frames); + return frames; + default: + return -EBADFD; + } +} + +static ssize_t snd_pcm_null_fwd(snd_pcm_t *pcm, size_t size) +{ + snd_pcm_null_t *null = pcm->private; + switch (null->state) { + case SND_PCM_STATE_PREPARED: + case SND_PCM_STATE_RUNNING: + snd_pcm_mmap_appl_forward(pcm, size); + snd_pcm_mmap_hw_forward(pcm, size); + return size; + default: + return -EBADFD; + } +} + +static ssize_t snd_pcm_null_writei(snd_pcm_t *pcm, const void *buffer ATTRIBUTE_UNUSED, size_t size) +{ + snd_pcm_null_t *null = pcm->private; + if (null->state == SND_PCM_STATE_PREPARED && + pcm->setup.start_mode != SND_PCM_START_EXPLICIT) { + null->state = SND_PCM_STATE_RUNNING; + } + return snd_pcm_null_fwd(pcm, size); +} + +static ssize_t snd_pcm_null_writen(snd_pcm_t *pcm, void **bufs ATTRIBUTE_UNUSED, size_t size) +{ + snd_pcm_null_t *null = pcm->private; + if (null->state == SND_PCM_STATE_PREPARED && + pcm->setup.start_mode != SND_PCM_START_EXPLICIT) { + null->state = SND_PCM_STATE_RUNNING; + } + return snd_pcm_null_fwd(pcm, size); +} + +static ssize_t snd_pcm_null_readi(snd_pcm_t *pcm, void *buffer ATTRIBUTE_UNUSED, size_t size) +{ + snd_pcm_null_t *null = pcm->private; + if (null->state == SND_PCM_STATE_PREPARED && + pcm->setup.start_mode != SND_PCM_START_EXPLICIT) { + null->state = SND_PCM_STATE_RUNNING; + snd_pcm_mmap_hw_forward(pcm, pcm->setup.buffer_size); + } + return snd_pcm_null_fwd(pcm, size); +} + +static ssize_t snd_pcm_null_readn(snd_pcm_t *pcm, void **bufs ATTRIBUTE_UNUSED, size_t size) +{ + snd_pcm_null_t *null = pcm->private; + if (null->state == SND_PCM_STATE_PREPARED && + pcm->setup.start_mode != SND_PCM_START_EXPLICIT) { + null->state = SND_PCM_STATE_RUNNING; + snd_pcm_mmap_hw_forward(pcm, pcm->setup.buffer_size); + } + return snd_pcm_null_fwd(pcm, size); +} + +static ssize_t snd_pcm_null_mmap_forward(snd_pcm_t *pcm, size_t size) +{ + return snd_pcm_null_fwd(pcm, size); +} + +static ssize_t snd_pcm_null_avail_update(snd_pcm_t *pcm) +{ + return pcm->setup.buffer_size; +} + +static int snd_pcm_null_set_avail_min(snd_pcm_t *pcm, size_t frames) +{ + pcm->setup.buffer_size = frames; + return 0; +} + +static int snd_pcm_null_mmap(snd_pcm_t *pcm) +{ + snd_pcm_mmap_info_t *i; + int err; + i = calloc(1, sizeof(*i)); + if (!i) + return -ENOMEM; + err = snd_pcm_alloc_user_mmap(pcm, i); + if (err < 0) { + free(i); + return err; + } + pcm->mmap_info = i; + pcm->mmap_info_count = 1; + return 0; +} + +static int snd_pcm_null_munmap(snd_pcm_t *pcm) +{ + int err = snd_pcm_free_mmap(pcm, pcm->mmap_info); + if (err < 0) + return err; + free(pcm->mmap_info); + pcm->mmap_info_count = 0; + pcm->mmap_info = 0; + return 0; +} + +static int snd_pcm_null_params_info(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_params_info_t * info) +{ + int sizes = ((info->req_mask & SND_PCM_PARAMS_SFMT) && + (info->req_mask & SND_PCM_PARAMS_CHANNELS)); + info->flags = SND_PCM_INFO_MMAP | SND_PCM_INFO_MMAP_VALID | + SND_PCM_INFO_INTERLEAVED | SND_PCM_INFO_NONINTERLEAVED | + SND_PCM_INFO_PAUSE; + info->formats = ~0; + info->rates = SND_PCM_RATE_CONTINUOUS | SND_PCM_RATE_8000_192000; + info->min_rate = 4000; + info->max_rate = 192000; + info->min_channels = 1; + info->max_channels = 32; + info->min_fragments = 1; + info->max_fragments = 1024 * 1024; + if (sizes) { + info->buffer_size = 1024 * 1024; + info->min_fragment_size = 1; + info->max_fragment_size = 1024 * 1024; + info->fragment_align = 1; + } + return 0; +} + +static int snd_pcm_null_params(snd_pcm_t *pcm, snd_pcm_params_t * params) +{ + snd_pcm_null_t *null = pcm->private; + snd_pcm_setup_t *s = &null->setup; + int w = snd_pcm_format_width(s->format.sfmt); + if (w < 0) { + params->fail_mask = SND_PCM_PARAMS_SFMT; + return -EINVAL; + } + s->msbits = w; + s->format = params->format; + s->start_mode = params->start_mode; + s->ready_mode = params->ready_mode; + s->avail_min = params->avail_min; + s->xfer_mode = params->xfer_mode; + s->xfer_min = params->xfer_min; + s->xfer_align = params->xfer_align; + s->xrun_mode = params->xrun_mode; + s->mmap_shape = params->mmap_shape; + s->frag_size = params->frag_size; + s->frags = s->buffer_size / s->frag_size; + if (s->frags < 1) + s->frags = 1; + s->buffer_size = s->frag_size * s->frags; + s->boundary = LONG_MAX - LONG_MAX % s->buffer_size; + s->time = params->time; + s->rate_master = s->format.rate; + s->rate_divisor = 1; + s->mmap_bytes = 0; + s->fifo_size = 1; + return 0; +} + +static int snd_pcm_null_setup(snd_pcm_t *pcm, snd_pcm_setup_t * setup) +{ + snd_pcm_null_t *null = pcm->private; + *setup = null->setup; + return 0; +} + +static void snd_pcm_null_dump(snd_pcm_t *pcm, FILE *fp) +{ + fprintf(fp, "Null PCM\n"); + if (pcm->valid_setup) { + fprintf(fp, "Its setup is:\n"); + snd_pcm_dump_setup(pcm, fp); + } +} + +snd_pcm_ops_t snd_pcm_null_ops = { + close: snd_pcm_null_close, + info: snd_pcm_null_info, + params_info: snd_pcm_null_params_info, + params: snd_pcm_null_params, + setup: snd_pcm_null_setup, + channel_info: snd_pcm_null_channel_info, + channel_params: snd_pcm_null_channel_params, + channel_setup: snd_pcm_null_channel_setup, + dump: snd_pcm_null_dump, + nonblock: snd_pcm_null_nonblock, + async: snd_pcm_null_async, + mmap: snd_pcm_null_mmap, + munmap: snd_pcm_null_munmap, +}; + +snd_pcm_fast_ops_t snd_pcm_null_fast_ops = { + status: snd_pcm_null_status, + state: snd_pcm_null_state, + delay: snd_pcm_null_delay, + prepare: snd_pcm_null_prepare, + start: snd_pcm_null_start, + drop: snd_pcm_null_drop, + drain: snd_pcm_null_drain, + pause: snd_pcm_null_pause, + rewind: snd_pcm_null_rewind, + writei: snd_pcm_null_writei, + writen: snd_pcm_null_writen, + readi: snd_pcm_null_readi, + readn: snd_pcm_null_readn, + avail_update: snd_pcm_null_avail_update, + mmap_forward: snd_pcm_null_mmap_forward, + set_avail_min: snd_pcm_null_set_avail_min, +}; + +int snd_pcm_null_open(snd_pcm_t **pcmp, char *name, int stream, int mode) +{ + snd_pcm_t *pcm; + snd_pcm_null_t *null; + int fd; + assert(pcmp); + if (stream == SND_PCM_STREAM_PLAYBACK) { + fd = open("/dev/null", O_WRONLY); + if (fd < 0) { + SYSERR("Cannot open /dev/null"); + return -errno; + } + } else { + fd = open("/dev/full", O_RDONLY); + if (fd < 0) { + SYSERR("Cannot open /dev/full"); + return -errno; + } + } + null = calloc(1, sizeof(snd_pcm_null_t)); + if (!null) { + close(fd); + return -ENOMEM; + } + null->poll_fd = fd; + null->state = SND_PCM_STATE_OPEN; + + pcm = calloc(1, sizeof(snd_pcm_t)); + if (!pcm) { + close(fd); + free(null); + return -ENOMEM; + } + if (name) + pcm->name = strdup(name); + pcm->type = SND_PCM_TYPE_NULL; + pcm->stream = stream; + pcm->mode = mode; + pcm->ops = &snd_pcm_null_ops; + pcm->op_arg = pcm; + pcm->fast_ops = &snd_pcm_null_fast_ops; + pcm->fast_op_arg = pcm; + pcm->private = null; + pcm->poll_fd = fd; + pcm->hw_ptr = &null->hw_ptr; + pcm->appl_ptr = &null->appl_ptr; + *pcmp = pcm; + + return 0; +} + +int _snd_pcm_null_open(snd_pcm_t **pcmp, char *name, + snd_config_t *conf, + int stream, int mode) +{ + snd_config_iterator_t i; + snd_config_foreach(i, conf) { + snd_config_t *n = snd_config_entry(i); + if (strcmp(n->id, "comment") == 0) + continue; + if (strcmp(n->id, "type") == 0) + continue; + if (strcmp(n->id, "stream") == 0) + continue; + return -EINVAL; + } + return snd_pcm_null_open(pcmp, name, stream, mode); +} diff --git a/src/pcm/pcm_plugin.c b/src/pcm/pcm_plugin.c index 9d881264..303f4819 100644 --- a/src/pcm/pcm_plugin.c +++ b/src/pcm/pcm_plugin.c @@ -354,12 +354,6 @@ int snd_pcm_plugin_poll_descriptor(snd_pcm_t *pcm) return snd_pcm_poll_descriptor(plugin->slave); } -int snd_pcm_plugin_channels_mask(snd_pcm_t *pcm, bitset_t *cmask) -{ - snd_pcm_plugin_t *plugin = pcm->private; - return snd_pcm_channels_mask(plugin->slave, cmask); -} - int conv_index(int src_format, int dst_format) { int src_endian, dst_endian, sign, src_width, dst_width; @@ -414,7 +408,6 @@ snd_pcm_fast_ops_t snd_pcm_plugin_fast_ops = { writen: snd_pcm_plugin_writen, readi: snd_pcm_plugin_readi, readn: snd_pcm_plugin_readn, - channels_mask: snd_pcm_plugin_channels_mask, avail_update: snd_pcm_plugin_avail_update, mmap_forward: snd_pcm_plugin_mmap_forward, set_avail_min: snd_pcm_plugin_set_avail_min, diff --git a/src/pcm/pcm_share.c b/src/pcm/pcm_share.c index 541bafc4..85edc923 100644 --- a/src/pcm/pcm_share.c +++ b/src/pcm/pcm_share.c @@ -991,22 +991,6 @@ static int snd_pcm_share_set_avail_min(snd_pcm_t *pcm, size_t frames) return 0; } -static int snd_pcm_share_channels_mask(snd_pcm_t *pcm, bitset_t *cmask) -{ - snd_pcm_share_t *share = pcm->private; - snd_pcm_share_slave_t *slave = share->slave; - unsigned int i; - bitset_t m[bitset_size(slave->channels_count)]; - int err = snd_pcm_channels_mask(slave->pcm, m); - if (err < 0) - return err; - for (i = 0; i < share->channels_count; ++i) { - if (!bitset_get(m, share->slave_channels[i])) - bitset_reset(cmask, i); - } - return 0; -} - /* Warning: take the mutex before to call this */ static void _snd_pcm_share_stop(snd_pcm_t *pcm, int state) { @@ -1205,7 +1189,6 @@ snd_pcm_fast_ops_t snd_pcm_share_fast_ops = { readi: snd_pcm_mmap_readi, readn: snd_pcm_mmap_readn, rewind: snd_pcm_share_rewind, - channels_mask: snd_pcm_share_channels_mask, avail_update: snd_pcm_share_avail_update, mmap_forward: snd_pcm_share_mmap_forward, set_avail_min: snd_pcm_share_set_avail_min, diff --git a/src/pcm/pcm_shm.c b/src/pcm/pcm_shm.c index 6ebbf3b3..0878bc17 100644 --- a/src/pcm/pcm_shm.c +++ b/src/pcm/pcm_shm.c @@ -466,12 +466,6 @@ static int snd_pcm_shm_poll_descriptor(snd_pcm_t *pcm) return fd; } -static int snd_pcm_shm_channels_mask(snd_pcm_t *pcm ATTRIBUTE_UNUSED, - bitset_t *cmask ATTRIBUTE_UNUSED) -{ - return 0; -} - static int snd_pcm_shm_close(snd_pcm_t *pcm) { snd_pcm_shm_t *shm = pcm->private; @@ -525,7 +519,6 @@ snd_pcm_fast_ops_t snd_pcm_shm_fast_ops = { writen: snd_pcm_mmap_writen, readi: snd_pcm_mmap_readi, readn: snd_pcm_mmap_readn, - channels_mask: snd_pcm_shm_channels_mask, avail_update: snd_pcm_shm_avail_update, mmap_forward: snd_pcm_shm_mmap_forward, set_avail_min: snd_pcm_shm_set_avail_min,