Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 *  Route Plug-In

 *  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

 *

 */

#include <sound/driver.h>

#include <linux/slab.h>

#include <linux/time.h>

#include <sound/core.h>

#include <sound/pcm.h>

#include "pcm_plugin.h"

static void zero_areas(struct snd_pcm_plugin_channel *dvp, int ndsts,

                       snd_pcm_uframes_t frames, int format)

{

        int dst = 0;

        for (; dst < ndsts; ++dst) {

                if (dvp->wanted)

                        snd_pcm_area_silence(&dvp->area, 0, frames, format);

                dvp->enabled = 0;

                dvp++;

        }

}

static inline void copy_area(const struct snd_pcm_plugin_channel *src_channel,

                             struct snd_pcm_plugin_channel *dst_channel,

                             snd_pcm_uframes_t frames, int format)

{

        dst_channel->enabled = 1;

        snd_pcm_area_copy(&src_channel->area, 0, &dst_channel->area, 0, frames, format);

}

static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin,

                                        const struct snd_pcm_plugin_channel *src_channels,

                                        struct snd_pcm_plugin_channel *dst_channels,

                                        snd_pcm_uframes_t frames)

{

        int nsrcs, ndsts, dst;

        struct snd_pcm_plugin_channel *dvp;

        int format;

        snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO);

        if (frames == 0)

                return 0;

        nsrcs = plugin->src_format.channels;

        ndsts = plugin->dst_format.channels;

        format = plugin->dst_format.format;

        dvp = dst_channels;

        if (nsrcs <= 1) {

                /* expand to all channels */

                for (dst = 0; dst < ndsts; ++dst) {

                        copy_area(src_channels, dvp, frames, format);

                        dvp++;

                }

                return frames;

        }

        for (dst = 0; dst < ndsts && dst < nsrcs; ++dst) {

                copy_area(src_channels, dvp, frames, format);

                dvp++;

                src_channels++;

        }

        if (dst < ndsts)

                zero_areas(dvp, ndsts - dst, frames, format);

        return frames;

}

int snd_pcm_plugin_build_route(struct snd_pcm_substream *plug,

                               struct snd_pcm_plugin_format *src_format,

                               struct snd_pcm_plugin_format *dst_format,

                               struct snd_pcm_plugin **r_plugin)

{

        struct snd_pcm_plugin *plugin;

        int err;

        snd_assert(r_plugin != NULL, return -ENXIO);

        *r_plugin = NULL;

        snd_assert(src_format->rate == dst_format->rate, return -ENXIO);

        snd_assert(src_format->format == dst_format->format, return -ENXIO);

        err = snd_pcm_plugin_build(plug, "route conversion",

                                   src_format, dst_format, 0, &plugin);

        if (err < 0)

                return err;

        plugin->transfer = route_transfer;

        *r_plugin = plugin;

        return 0;

}