Linux-2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 921 insertions, 0 deletions

diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c
new file mode 100644
index 00000000000..6bb31009f0b
--- /dev/null
+++ b/sound/core/oss/pcm_plugin.c
@@ -0,0 +1,921 @@
+/*
+ *  PCM Plug-In shared (kernel/library) code
+ *  Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz>
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+  
+#if 0
+#define PLUGIN_DEBUG
+#endif
+
+#include <sound/driver.h>
+#include <linux/slab.h>
+#include <linux/time.h>
+#include <linux/vmalloc.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include "pcm_plugin.h"
+
+#define snd_pcm_plug_first(plug) ((plug)->runtime->oss.plugin_first)
+#define snd_pcm_plug_last(plug) ((plug)->runtime->oss.plugin_last)
+
+static int snd_pcm_plugin_src_channels_mask(snd_pcm_plugin_t *plugin,
+                                            bitset_t *dst_vmask,
+                                            bitset_t **src_vmask)
+{
+        bitset_t *vmask = plugin->src_vmask;
+        bitset_copy(vmask, dst_vmask, plugin->src_format.channels);
+        *src_vmask = vmask;
+        return 0;
+}
+
+static int snd_pcm_plugin_dst_channels_mask(snd_pcm_plugin_t *plugin,
+                                            bitset_t *src_vmask,
+                                            bitset_t **dst_vmask)
+{
+        bitset_t *vmask = plugin->dst_vmask;
+        bitset_copy(vmask, src_vmask, plugin->dst_format.channels);
+        *dst_vmask = vmask;
+        return 0;
+}
+
+/*
+ *  because some cards might have rates "very close", we ignore
+ *  all "resampling" requests within +-5%
+ */
+static int rate_match(unsigned int src_rate, unsigned int dst_rate)
+{
+        unsigned int low = (src_rate * 95) / 100;
+        unsigned int high = (src_rate * 105) / 100;
+        return dst_rate >= low && dst_rate <= high;
+}
+
+static int snd_pcm_plugin_alloc(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames)
+{
+        snd_pcm_plugin_format_t *format;
+        ssize_t width;
+        size_t size;
+        unsigned int channel;
+        snd_pcm_plugin_channel_t *c;
+
+        if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                format = &plugin->src_format;
+        } else {
+                format = &plugin->dst_format;
+        }
+        if ((width = snd_pcm_format_physical_width(format->format)) < 0)
+                return width;
+        size = frames * format->channels * width;
+        snd_assert((size % 8) == 0, return -ENXIO);
+        size /= 8;
+        if (plugin->buf_frames < frames) {
+                vfree(plugin->buf);
+                plugin->buf = vmalloc(size);
+                plugin->buf_frames = frames;
+        }
+        if (!plugin->buf) {
+                plugin->buf_frames = 0;
+                return -ENOMEM;
+        }
+        c = plugin->buf_channels;
+        if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) {
+                for (channel = 0; channel < format->channels; channel++, c++) {
+                        c->frames = frames;
+                        c->enabled = 1;
+                        c->wanted = 0;
+                        c->area.addr = plugin->buf;
+                        c->area.first = channel * width;
+                        c->area.step = format->channels * width;
+                }
+        } else if (plugin->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) {
+                snd_assert((size % format->channels) == 0,);
+                size /= format->channels;
+                for (channel = 0; channel < format->channels; channel++, c++) {
+                        c->frames = frames;
+                        c->enabled = 1;
+                        c->wanted = 0;
+                        c->area.addr = plugin->buf + (channel * size);
+                        c->area.first = 0;
+                        c->area.step = width;
+                }
+        } else
+                return -EINVAL;
+        return 0;
+}
+
+int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames)
+{
+        int err;
+        snd_assert(snd_pcm_plug_first(plug) != NULL, return -ENXIO);
+        if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) {
+                snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug);
+                while (plugin->next) {
+                        if (plugin->dst_frames)
+                                frames = plugin->dst_frames(plugin, frames);
+                        snd_assert(frames > 0, return -ENXIO);
+                        plugin = plugin->next;
+                        err = snd_pcm_plugin_alloc(plugin, frames);
+                        if (err < 0)
+                                return err;
+                }
+        } else {
+                snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug);
+                while (plugin->prev) {
+                        if (plugin->src_frames)
+                                frames = plugin->src_frames(plugin, frames);
+                        snd_assert(frames > 0, return -ENXIO);
+                        plugin = plugin->prev;
+                        err = snd_pcm_plugin_alloc(plugin, frames);
+                        if (err < 0)
+                                return err;
+                }
+        }
+        return 0;
+}
+
+
+snd_pcm_sframes_t snd_pcm_plugin_client_channels(snd_pcm_plugin_t *plugin,
+                                       snd_pcm_uframes_t frames,
+                                       snd_pcm_plugin_channel_t **channels)
+{
+        *channels = plugin->buf_channels;
+        return frames;
+}
+
+int snd_pcm_plugin_build(snd_pcm_plug_t *plug,
+                         const char *name,
+                         snd_pcm_plugin_format_t *src_format,
+                         snd_pcm_plugin_format_t *dst_format,
+                         size_t extra,
+                         snd_pcm_plugin_t **ret)
+{
+        snd_pcm_plugin_t *plugin;
+        unsigned int channels;
+        
+        snd_assert(plug != NULL, return -ENXIO);
+        snd_assert(src_format != NULL && dst_format != NULL, return -ENXIO);
+        plugin = kcalloc(1, sizeof(*plugin) + extra, GFP_KERNEL);
+        if (plugin == NULL)
+                return -ENOMEM;
+        plugin->name = name;
+        plugin->plug = plug;
+        plugin->stream = snd_pcm_plug_stream(plug);
+        plugin->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
+        plugin->src_format = *src_format;
+        plugin->src_width = snd_pcm_format_physical_width(src_format->format);
+        snd_assert(plugin->src_width > 0, );
+        plugin->dst_format = *dst_format;
+        plugin->dst_width = snd_pcm_format_physical_width(dst_format->format);
+        snd_assert(plugin->dst_width > 0, );
+        if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                channels = src_format->channels;
+        else
+                channels = dst_format->channels;
+        plugin->buf_channels = kcalloc(channels, sizeof(*plugin->buf_channels), GFP_KERNEL);
+        if (plugin->buf_channels == NULL) {
+                snd_pcm_plugin_free(plugin);
+                return -ENOMEM;
+        }
+        plugin->src_vmask = bitset_alloc(src_format->channels);
+        if (plugin->src_vmask == NULL) {
+                snd_pcm_plugin_free(plugin);
+                return -ENOMEM;
+        }
+        plugin->dst_vmask = bitset_alloc(dst_format->channels);
+        if (plugin->dst_vmask == NULL) {
+                snd_pcm_plugin_free(plugin);
+                return -ENOMEM;
+        }
+        plugin->client_channels = snd_pcm_plugin_client_channels;
+        plugin->src_channels_mask = snd_pcm_plugin_src_channels_mask;
+        plugin->dst_channels_mask = snd_pcm_plugin_dst_channels_mask;
+        *ret = plugin;
+        return 0;
+}
+
+int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin)
+{
+        if (! plugin)
+                return 0;
+        if (plugin->private_free)
+                plugin->private_free(plugin);
+        kfree(plugin->buf_channels);
+        vfree(plugin->buf);
+        kfree(plugin->src_vmask);
+        kfree(plugin->dst_vmask);
+        kfree(plugin);
+        return 0;
+}
+
+snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t drv_frames)
+{
+        snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next;
+        int stream = snd_pcm_plug_stream(plug);
+
+        snd_assert(plug != NULL, return -ENXIO);
+        if (drv_frames == 0)
+                return 0;
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                plugin = snd_pcm_plug_last(plug);
+                while (plugin && drv_frames > 0) {
+                        plugin_prev = plugin->prev;
+                        if (plugin->src_frames)
+                                drv_frames = plugin->src_frames(plugin, drv_frames);
+                        plugin = plugin_prev;
+                }
+        } else if (stream == SNDRV_PCM_STREAM_CAPTURE) {
+                plugin = snd_pcm_plug_first(plug);
+                while (plugin && drv_frames > 0) {
+                        plugin_next = plugin->next;
+                        if (plugin->dst_frames)
+                                drv_frames = plugin->dst_frames(plugin, drv_frames);
+                        plugin = plugin_next;
+                }
+        } else
+                snd_BUG();
+        return drv_frames;
+}
+
+snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t clt_frames)
+{
+        snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next;
+        snd_pcm_sframes_t frames;
+        int stream = snd_pcm_plug_stream(plug);
+        
+        snd_assert(plug != NULL, return -ENXIO);
+        if (clt_frames == 0)
+                return 0;
+        frames = clt_frames;
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                plugin = snd_pcm_plug_first(plug);
+                while (plugin && frames > 0) {
+                        plugin_next = plugin->next;
+                        if (plugin->dst_frames) {
+                                frames = plugin->dst_frames(plugin, frames);
+                                if (frames < 0)
+                                        return frames;
+                        }
+                        plugin = plugin_next;
+                }
+        } else if (stream == SNDRV_PCM_STREAM_CAPTURE) {
+                plugin = snd_pcm_plug_last(plug);
+                while (plugin) {
+                        plugin_prev = plugin->prev;
+                        if (plugin->src_frames) {
+                                frames = plugin->src_frames(plugin, frames);
+                                if (frames < 0)
+                                        return frames;
+                        }
+                        plugin = plugin_prev;
+                }
+        } else
+                snd_BUG();
+        return frames;
+}
+
+static int snd_pcm_plug_formats(snd_mask_t *mask, int format)
+{
+        snd_mask_t formats = *mask;
+        u64 linfmts = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 |
+                       SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_S16_LE |
+                       SNDRV_PCM_FMTBIT_U16_BE | SNDRV_PCM_FMTBIT_S16_BE |
+                       SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_S24_LE |
+                       SNDRV_PCM_FMTBIT_U24_BE | SNDRV_PCM_FMTBIT_S24_BE |
+                       SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_S32_LE |
+                       SNDRV_PCM_FMTBIT_U32_BE | SNDRV_PCM_FMTBIT_S32_BE);
+        snd_mask_set(&formats, SNDRV_PCM_FORMAT_MU_LAW);
+        
+        if (formats.bits[0] & (u32)linfmts)
+                formats.bits[0] |= (u32)linfmts;
+        if (formats.bits[1] & (u32)(linfmts >> 32))
+                formats.bits[1] |= (u32)(linfmts >> 32);
+        return snd_mask_test(&formats, format);
+}
+
+static int preferred_formats[] = {
+        SNDRV_PCM_FORMAT_S16_LE,
+        SNDRV_PCM_FORMAT_S16_BE,
+        SNDRV_PCM_FORMAT_U16_LE,
+        SNDRV_PCM_FORMAT_U16_BE,
+        SNDRV_PCM_FORMAT_S24_LE,
+        SNDRV_PCM_FORMAT_S24_BE,
+        SNDRV_PCM_FORMAT_U24_LE,
+        SNDRV_PCM_FORMAT_U24_BE,
+        SNDRV_PCM_FORMAT_S32_LE,
+        SNDRV_PCM_FORMAT_S32_BE,
+        SNDRV_PCM_FORMAT_U32_LE,
+        SNDRV_PCM_FORMAT_U32_BE,
+        SNDRV_PCM_FORMAT_S8,
+        SNDRV_PCM_FORMAT_U8
+};
+
+int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask)
+{
+        if (snd_mask_test(format_mask, format))
+                return format;
+        if (! snd_pcm_plug_formats(format_mask, format))
+                return -EINVAL;
+        if (snd_pcm_format_linear(format)) {
+                int width = snd_pcm_format_width(format);
+                int unsignd = snd_pcm_format_unsigned(format);
+                int big = snd_pcm_format_big_endian(format);
+                int format1;
+                int wid, width1=width;
+                int dwidth1 = 8;
+                for (wid = 0; wid < 4; ++wid) {
+                        int end, big1 = big;
+                        for (end = 0; end < 2; ++end) {
+                                int sgn, unsignd1 = unsignd;
+                                for (sgn = 0; sgn < 2; ++sgn) {
+                                        format1 = snd_pcm_build_linear_format(width1, unsignd1, big1);
+                                        if (format1 >= 0 &&
+                                            snd_mask_test(format_mask, format1))
+                                                goto _found;
+                                        unsignd1 = !unsignd1;
+                                }
+                                big1 = !big1;
+                        }
+                        if (width1 == 32) {
+                                dwidth1 = -dwidth1;
+                                width1 = width;
+                        }
+                        width1 += dwidth1;
+                }
+                return -EINVAL;
+        _found:
+                return format1;
+        } else {
+                unsigned int i;
+                switch (format) {
+                case SNDRV_PCM_FORMAT_MU_LAW:
+                        for (i = 0; i < ARRAY_SIZE(preferred_formats); ++i) {
+                                int format1 = preferred_formats[i];
+                                if (snd_mask_test(format_mask, format1))
+                                        return format1;
+                        }
+                default:
+                        return -EINVAL;
+                }
+        }
+}
+
+int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug,
+                                snd_pcm_hw_params_t *params,
+                                snd_pcm_hw_params_t *slave_params)
+{
+        snd_pcm_plugin_format_t tmpformat;
+        snd_pcm_plugin_format_t dstformat;
+        snd_pcm_plugin_format_t srcformat;
+        int src_access, dst_access;
+        snd_pcm_plugin_t *plugin = NULL;
+        int err;
+        int stream = snd_pcm_plug_stream(plug);
+        int slave_interleaved = (params_channels(slave_params) == 1 ||
+                                 params_access(slave_params) == SNDRV_PCM_ACCESS_RW_INTERLEAVED);
+
+        switch (stream) {
+        case SNDRV_PCM_STREAM_PLAYBACK:
+                dstformat.format = params_format(slave_params);
+                dstformat.rate = params_rate(slave_params);
+                dstformat.channels = params_channels(slave_params);
+                srcformat.format = params_format(params);
+                srcformat.rate = params_rate(params);
+                srcformat.channels = params_channels(params);
+                src_access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
+                dst_access = (slave_interleaved ? SNDRV_PCM_ACCESS_RW_INTERLEAVED :
+                                                  SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
+                break;
+        case SNDRV_PCM_STREAM_CAPTURE:
+                dstformat.format = params_format(params);
+                dstformat.rate = params_rate(params);
+                dstformat.channels = params_channels(params);
+                srcformat.format = params_format(slave_params);
+                srcformat.rate = params_rate(slave_params);
+                srcformat.channels = params_channels(slave_params);
+                src_access = (slave_interleaved ? SNDRV_PCM_ACCESS_RW_INTERLEAVED :
+                                                  SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
+                dst_access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
+                break;
+        default:
+                snd_BUG();
+                return -EINVAL;
+        }
+        tmpformat = srcformat;
+                
+        pdprintf("srcformat: format=%i, rate=%i, channels=%i\n", 
+                 srcformat.format,
+                 srcformat.rate,
+                 srcformat.channels);
+        pdprintf("dstformat: format=%i, rate=%i, channels=%i\n", 
+                 dstformat.format,
+                 dstformat.rate,
+                 dstformat.channels);
+
+        /* Format change (linearization) */
+        if ((srcformat.format != dstformat.format ||
+             !rate_match(srcformat.rate, dstformat.rate) ||
+             srcformat.channels != dstformat.channels) &&
+            !snd_pcm_format_linear(srcformat.format)) {
+                if (snd_pcm_format_linear(dstformat.format))
+                        tmpformat.format = dstformat.format;
+                else
+                        tmpformat.format = SNDRV_PCM_FORMAT_S16;
+                switch (srcformat.format) {
+                case SNDRV_PCM_FORMAT_MU_LAW:
+                        err = snd_pcm_plugin_build_mulaw(plug,
+                                                         &srcformat, &tmpformat,
+                                                         &plugin);
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                pdprintf("format change: src=%i, dst=%i returns %i\n", srcformat.format, tmpformat.format, err);
+                if (err < 0)
+                        return err;
+                err = snd_pcm_plugin_append(plugin);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }
+                srcformat = tmpformat;
+                src_access = dst_access;
+        }
+
+        /* channels reduction */
+        if (srcformat.channels > dstformat.channels) {
+                int sv = srcformat.channels;
+                int dv = dstformat.channels;
+                route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL);
+                if (ttable == NULL)
+                        return -ENOMEM;
+#if 1
+                if (sv == 2 && dv == 1) {
+                        ttable[0] = HALF;
+                        ttable[1] = HALF;
+                } else
+#endif
+                {
+                        int v;
+                        for (v = 0; v < dv; ++v)
+                                ttable[v * sv + v] = FULL;
+                }
+                tmpformat.channels = dstformat.channels;
+                if (rate_match(srcformat.rate, dstformat.rate) &&
+                    snd_pcm_format_linear(dstformat.format))
+                        tmpformat.format = dstformat.format;
+                err = snd_pcm_plugin_build_route(plug,
+                                                 &srcformat, &tmpformat,
+                                                 ttable, &plugin);
+                kfree(ttable);
+                pdprintf("channels reduction: src=%i, dst=%i returns %i\n", srcformat.channels, tmpformat.channels, err);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }
+                err = snd_pcm_plugin_append(plugin);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }
+                srcformat = tmpformat;
+                src_access = dst_access;
+        }
+
+        /* rate resampling */
+        if (!rate_match(srcformat.rate, dstformat.rate)) {
+                tmpformat.rate = dstformat.rate;
+                if (srcformat.channels == dstformat.channels &&
+                    snd_pcm_format_linear(dstformat.format))
+                        tmpformat.format = dstformat.format;
+                err = snd_pcm_plugin_build_rate(plug,
+                                                &srcformat, &tmpformat,
+                                                &plugin);
+                pdprintf("rate down resampling: src=%i, dst=%i returns %i\n", srcformat.rate, tmpformat.rate, err);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }                                           
+                err = snd_pcm_plugin_append(plugin);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }
+                srcformat = tmpformat;
+                src_access = dst_access;
+        }
+
+        /* channels extension  */
+        if (srcformat.channels < dstformat.channels) {
+                int sv = srcformat.channels;
+                int dv = dstformat.channels;
+                route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL);
+                if (ttable == NULL)
+                        return -ENOMEM;
+#if 0
+                {
+                        int v;
+                        for (v = 0; v < sv; ++v)
+                                ttable[v * sv + v] = FULL;
+                }
+#else
+                {
+                        /* Playback is spreaded on all channels */
+                        int vd, vs;
+                        for (vd = 0, vs = 0; vd < dv; ++vd) {
+                                ttable[vd * sv + vs] = FULL;
+                                vs++;
+                                if (vs == sv)
+                                        vs = 0;
+                        }
+                }
+#endif
+                tmpformat.channels = dstformat.channels;
+                if (snd_pcm_format_linear(dstformat.format))
+                        tmpformat.format = dstformat.format;
+                err = snd_pcm_plugin_build_route(plug,
+                                                 &srcformat, &tmpformat,
+                                                 ttable, &plugin);
+                kfree(ttable);
+                pdprintf("channels extension: src=%i, dst=%i returns %i\n", srcformat.channels, tmpformat.channels, err);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }                                           
+                err = snd_pcm_plugin_append(plugin);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }
+                srcformat = tmpformat;
+                src_access = dst_access;
+        }
+
+        /* format change */
+        if (srcformat.format != dstformat.format) {
+                tmpformat.format = dstformat.format;
+                if (tmpformat.format == SNDRV_PCM_FORMAT_MU_LAW) {
+                        err = snd_pcm_plugin_build_mulaw(plug,
+                                                         &srcformat, &tmpformat,
+                                                         &plugin);
+                }
+                else if (snd_pcm_format_linear(srcformat.format) &&
+                         snd_pcm_format_linear(tmpformat.format)) {
+                        err = snd_pcm_plugin_build_linear(plug,
+                                                          &srcformat, &tmpformat,
+                                                          &plugin);
+                }
+                else
+                        return -EINVAL;
+                pdprintf("format change: src=%i, dst=%i returns %i\n", srcformat.format, tmpformat.format, err);
+                if (err < 0)
+                        return err;
+                err = snd_pcm_plugin_append(plugin);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }
+                srcformat = tmpformat;
+                src_access = dst_access;
+        }
+
+        /* de-interleave */
+        if (src_access != dst_access) {
+                err = snd_pcm_plugin_build_copy(plug,
+                                                &srcformat,
+                                                &tmpformat,
+                                                &plugin);
+                pdprintf("interleave change (copy: returns %i)\n", err);
+                if (err < 0)
+                        return err;
+                err = snd_pcm_plugin_append(plugin);
+                if (err < 0) {
+                        snd_pcm_plugin_free(plugin);
+                        return err;
+                }
+        }
+
+        return 0;
+}
+
+snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *plug,
+                                         char *buf,
+                                         snd_pcm_uframes_t count,
+                                         snd_pcm_plugin_channel_t **channels)
+{
+        snd_pcm_plugin_t *plugin;
+        snd_pcm_plugin_channel_t *v;
+        snd_pcm_plugin_format_t *format;
+        int width, nchannels, channel;
+        int stream = snd_pcm_plug_stream(plug);
+
+        snd_assert(buf != NULL, return -ENXIO);
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                plugin = snd_pcm_plug_first(plug);
+                format = &plugin->src_format;
+        } else {
+                plugin = snd_pcm_plug_last(plug);
+                format = &plugin->dst_format;
+        }
+        v = plugin->buf_channels;
+        *channels = v;
+        if ((width = snd_pcm_format_physical_width(format->format)) < 0)
+                return width;
+        nchannels = format->channels;
+        snd_assert(plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || format->channels <= 1, return -ENXIO);
+        for (channel = 0; channel < nchannels; channel++, v++) {
+                v->frames = count;
+                v->enabled = 1;
+                v->wanted = (stream == SNDRV_PCM_STREAM_CAPTURE);
+                v->area.addr = buf;
+                v->area.first = channel * width;
+                v->area.step = nchannels * width;
+        }
+        return count;
+}
+
+static int snd_pcm_plug_playback_channels_mask(snd_pcm_plug_t *plug,
+                                               bitset_t *client_vmask)
+{
+        snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug);
+        if (plugin == NULL) {
+                return 0;
+        } else {
+                int schannels = plugin->dst_format.channels;
+                bitset_t bs[bitset_size(schannels)];
+                bitset_t *srcmask;
+                bitset_t *dstmask = bs;
+                int err;
+                bitset_one(dstmask, schannels);
+                if (plugin == NULL) {
+                        bitset_and(client_vmask, dstmask, schannels);
+                        return 0;
+                }
+                while (1) {
+                        err = plugin->src_channels_mask(plugin, dstmask, &srcmask);
+                        if (err < 0)
+                                return err;
+                        dstmask = srcmask;
+                        if (plugin->prev == NULL)
+                                break;
+                        plugin = plugin->prev;
+                }
+                bitset_and(client_vmask, dstmask, plugin->src_format.channels);
+                return 0;
+        }
+}
+
+static int snd_pcm_plug_playback_disable_useless_channels(snd_pcm_plug_t *plug,
+                                                          snd_pcm_plugin_channel_t *src_channels)
+{
+        snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug);
+        unsigned int nchannels = plugin->src_format.channels;
+        bitset_t bs[bitset_size(nchannels)];
+        bitset_t *srcmask = bs;
+        int err;
+        unsigned int channel;
+        for (channel = 0; channel < nchannels; channel++) {
+                if (src_channels[channel].enabled)
+                        bitset_set(srcmask, channel);
+                else
+                        bitset_reset(srcmask, channel);
+        }
+        err = snd_pcm_plug_playback_channels_mask(plug, srcmask);
+        if (err < 0)
+                return err;
+        for (channel = 0; channel < nchannels; channel++) {
+                if (!bitset_get(srcmask, channel))
+                        src_channels[channel].enabled = 0;
+        }
+        return 0;
+}
+
+static int snd_pcm_plug_capture_disable_useless_channels(snd_pcm_plug_t *plug,
+                                                         snd_pcm_plugin_channel_t *src_channels,
+                                                         snd_pcm_plugin_channel_t *client_channels)
+{
+        snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug);
+        unsigned int nchannels = plugin->dst_format.channels;
+        bitset_t bs[bitset_size(nchannels)];
+        bitset_t *dstmask = bs;
+        bitset_t *srcmask;
+        int err;
+        unsigned int channel;
+        for (channel = 0; channel < nchannels; channel++) {
+                if (client_channels[channel].enabled)
+                        bitset_set(dstmask, channel);
+                else
+                        bitset_reset(dstmask, channel);
+        }
+        while (plugin) {
+                err = plugin->src_channels_mask(plugin, dstmask, &srcmask);
+                if (err < 0)
+                        return err;
+                dstmask = srcmask;
+                plugin = plugin->prev;
+        }
+        plugin = snd_pcm_plug_first(plug);
+        nchannels = plugin->src_format.channels;
+        for (channel = 0; channel < nchannels; channel++) {
+                if (!bitset_get(dstmask, channel))
+                        src_channels[channel].enabled = 0;
+        }
+        return 0;
+}
+
+snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *src_channels, snd_pcm_uframes_t size)
+{
+        snd_pcm_plugin_t *plugin, *next;
+        snd_pcm_plugin_channel_t *dst_channels;
+        int err;
+        snd_pcm_sframes_t frames = size;
+
+        if ((err = snd_pcm_plug_playback_disable_useless_channels(plug, src_channels)) < 0)
+                return err;
+        
+        plugin = snd_pcm_plug_first(plug);
+        while (plugin && frames > 0) {
+                if ((next = plugin->next) != NULL) {
+                        snd_pcm_sframes_t frames1 = frames;
+                        if (plugin->dst_frames)
+                                frames1 = plugin->dst_frames(plugin, frames);
+                        if ((err = next->client_channels(next, frames1, &dst_channels)) < 0) {
+                                return err;
+                        }
+                        if (err != frames1) {
+                                frames = err;
+                                if (plugin->src_frames)
+                                        frames = plugin->src_frames(plugin, frames1);
+                        }
+                } else
+                        dst_channels = NULL;
+                pdprintf("write plugin: %s, %li\n", plugin->name, frames);
+                if ((frames = plugin->transfer(plugin, src_channels, dst_channels, frames)) < 0)
+                        return frames;
+                src_channels = dst_channels;
+                plugin = next;
+        }
+        return snd_pcm_plug_client_size(plug, frames);
+}
+
+snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *dst_channels_final, snd_pcm_uframes_t size)
+{
+        snd_pcm_plugin_t *plugin, *next;
+        snd_pcm_plugin_channel_t *src_channels, *dst_channels;
+        snd_pcm_sframes_t frames = size;
+        int err;
+
+        frames = snd_pcm_plug_slave_size(plug, frames);
+        if (frames < 0)
+                return frames;
+
+        src_channels = NULL;
+        plugin = snd_pcm_plug_first(plug);
+        while (plugin && frames > 0) {
+                if ((next = plugin->next) != NULL) {
+                        if ((err = plugin->client_channels(plugin, frames, &dst_channels)) < 0) {
+                                return err;
+                        }
+                        frames = err;
+                        if (!plugin->prev) {
+                                if ((err = snd_pcm_plug_capture_disable_useless_channels(plug, dst_channels, dst_channels_final)) < 0)
+                                        return err;
+                        }
+                } else {
+                        dst_channels = dst_channels_final;
+                }
+                pdprintf("read plugin: %s, %li\n", plugin->name, frames);
+                if ((frames = plugin->transfer(plugin, src_channels, dst_channels, frames)) < 0)
+                        return frames;
+                plugin = next;
+                src_channels = dst_channels;
+        }
+        return frames;
+}
+
+int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offset,
+                         size_t samples, int format)
+{
+        /* FIXME: sub byte resolution and odd dst_offset */
+        unsigned char *dst;
+        unsigned int dst_step;
+        int width;
+        const unsigned char *silence;
+        if (!dst_area->addr)
+                return 0;
+        dst = dst_area->addr + (dst_area->first + dst_area->step * dst_offset) / 8;
+        width = snd_pcm_format_physical_width(format);
+        if (width <= 0)
+                return -EINVAL;
+        if (dst_area->step == (unsigned int) width && width >= 8)
+                return snd_pcm_format_set_silence(format, dst, samples);
+        silence = snd_pcm_format_silence_64(format);
+        if (! silence)
+                return -EINVAL;
+        dst_step = dst_area->step / 8;
+        if (width == 4) {
+                /* Ima ADPCM */
+                int dstbit = dst_area->first % 8;
+                int dstbit_step = dst_area->step % 8;
+                while (samples-- > 0) {
+                        if (dstbit)
+                                *dst &= 0xf0;
+                        else
+                                *dst &= 0x0f;
+                        dst += dst_step;
+                        dstbit += dstbit_step;
+                        if (dstbit == 8) {
+                                dst++;
+                                dstbit = 0;
+                        }
+                }
+        } else {
+                width /= 8;
+                while (samples-- > 0) {
+                        memcpy(dst, silence, width);
+                        dst += dst_step;
+                }
+        }
+        return 0;
+}
+
+int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_area, size_t src_offset,
+                      const snd_pcm_channel_area_t *dst_area, size_t dst_offset,
+                      size_t samples, int format)
+{
+        /* FIXME: sub byte resolution and odd dst_offset */
+        char *src, *dst;
+        int width;
+        int src_step, dst_step;
+        src = src_area->addr + (src_area->first + src_area->step * src_offset) / 8;
+        if (!src_area->addr)
+                return snd_pcm_area_silence(dst_area, dst_offset, samples, format);
+        dst = dst_area->addr + (dst_area->first + dst_area->step * dst_offset) / 8;
+        if (!dst_area->addr)
+                return 0;
+        width = snd_pcm_format_physical_width(format);
+        if (width <= 0)
+                return -EINVAL;
+        if (src_area->step == (unsigned int) width &&
+            dst_area->step == (unsigned int) width && width >= 8) {
+                size_t bytes = samples * width / 8;
+                memcpy(dst, src, bytes);
+                return 0;
+        }
+        src_step = src_area->step / 8;
+        dst_step = dst_area->step / 8;
+        if (width == 4) {
+                /* Ima ADPCM */
+                int srcbit = src_area->first % 8;
+                int srcbit_step = src_area->step % 8;
+                int dstbit = dst_area->first % 8;
+                int dstbit_step = dst_area->step % 8;
+                while (samples-- > 0) {
+                        unsigned char srcval;
+                        if (srcbit)
+                                srcval = *src & 0x0f;
+                        else
+                                srcval = (*src & 0xf0) >> 4;
+                        if (dstbit)
+                                *dst = (*dst & 0xf0) | srcval;
+                        else
+                                *dst = (*dst & 0x0f) | (srcval << 4);
+                        src += src_step;
+                        srcbit += srcbit_step;
+                        if (srcbit == 8) {
+                                src++;
+                                srcbit = 0;
+                        }
+                        dst += dst_step;
+                        dstbit += dstbit_step;
+                        if (dstbit == 8) {
+                                dst++;
+                                dstbit = 0;
+                        }
+                }
+        } else {
+                width /= 8;
+                while (samples-- > 0) {
+                        memcpy(dst, src, width);
+                        src += src_step;
+                        dst += dst_step;
+                }
+        }
+        return 0;
+}