Remove channels_mask. Implemented pcm_null

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

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;

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,

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,

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

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,

src/pcm/pcm_null.c

@@ -0,0 +1,442 @@
+/*
+ *  PCM - Null plugin
+ *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>
+ *
+ *
+ *   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 <byteswap.h>
+#include <limits.h>
+#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);
+}

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,

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,

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,