freebsd-dev/sys/dev/sound/pcm/feeder_fmt.c

/*-
 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org>
 * Copyright (c) 2005 Ariff Abdullah <ariff@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * *New* and rewritten soft format converter, supporting 24/32bit pcm data,
 * simplified and optimized.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *                                                                         *
 * This new implementation is fully dedicated in memory of Cameron Grant,  *
 * the creator of the magnificent, highly addictive feeder infrastructure. *
 *                                                                         *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 */

#include <dev/sound/pcm/sound.h>
#include "feeder_if.h"

SND_DECLARE_FILE("$FreeBSD$");

static int feeder_fmt_stereodownmix = 0;
TUNABLE_INT("hw.snd.feeder_fmt_stereodownmix", &feeder_fmt_stereodownmix);
#ifdef SND_DEBUG
SYSCTL_INT(_hw_snd, OID_AUTO, feeder_fmt_stereodownmix, CTLFLAG_RW,
	&feeder_fmt_stereodownmix, 1, "averaging stereo downmix");
#endif

#define FEEDFMT_RESERVOIR	8	/* 32bit stereo */

static uint8_t ulaw_to_u8_tbl[] = {
    3,    7,   11,   15,   19,   23,   27,   31,
   35,   39,   43,   47,   51,   55,   59,   63,
   66,   68,   70,   72,   74,   76,   78,   80,
   82,   84,   86,   88,   90,   92,   94,   96,
   98,   99,  100,  101,  102,  103,  104,  105,
  106,  107,  108,  109,  110,  111,  112,  113,
  113,  114,  114,  115,  115,  116,  116,  117,
  117,  118,  118,  119,  119,  120,  120,  121,
  121,  121,  122,  122,  122,  122,  123,  123,
  123,  123,  124,  124,  124,  124,  125,  125,
  125,  125,  125,  125,  126,  126,  126,  126,
  126,  126,  126,  126,  127,  127,  127,  127,
  127,  127,  127,  127,  127,  127,  127,  127,
  128,  128,  128,  128,  128,  128,  128,  128,
  128,  128,  128,  128,  128,  128,  128,  128,
  128,  128,  128,  128,  128,  128,  128,  128,
  253,  249,  245,  241,  237,  233,  229,  225,
  221,  217,  213,  209,  205,  201,  197,  193,
  190,  188,  186,  184,  182,  180,  178,  176,
  174,  172,  170,  168,  166,  164,  162,  160,
  158,  157,  156,  155,  154,  153,  152,  151,
  150,  149,  148,  147,  146,  145,  144,  143,
  143,  142,  142,  141,  141,  140,  140,  139,
  139,  138,  138,  137,  137,  136,  136,  135,
  135,  135,  134,  134,  134,  134,  133,  133,
  133,  133,  132,  132,  132,  132,  131,  131,
  131,  131,  131,  131,  130,  130,  130,  130,
  130,  130,  130,  130,  129,  129,  129,  129,
  129,  129,  129,  129,  129,  129,  129,  129,
  128,  128,  128,  128,  128,  128,  128,  128,
  128,  128,  128,  128,  128,  128,  128,  128,
  128,  128,  128,  128,  128,  128,  128,  128,
};

static uint8_t alaw_to_u8_tbl[] = {
  108,  109,  106,  107,  112,  113,  110,  111,
  100,  101,   98,   99,  104,  105,  102,  103,
  118,  118,  117,  117,  120,  120,  119,  119,
  114,  114,  113,  113,  116,  116,  115,  115,
   43,   47,   35,   39,   59,   63,   51,   55,
   11,   15,    3,    7,   27,   31,   19,   23,
   86,   88,   82,   84,   94,   96,   90,   92,
   70,   72,   66,   68,   78,   80,   74,   76,
  127,  127,  127,  127,  127,  127,  127,  127,
  127,  127,  127,  127,  127,  127,  127,  127,
  128,  128,  128,  128,  128,  128,  128,  128,
  128,  128,  128,  128,  128,  128,  128,  128,
  123,  123,  123,  123,  124,  124,  124,  124,
  121,  121,  121,  121,  122,  122,  122,  122,
  126,  126,  126,  126,  126,  126,  126,  126,
  125,  125,  125,  125,  125,  125,  125,  125,
  148,  147,  150,  149,  144,  143,  146,  145,
  156,  155,  158,  157,  152,  151,  154,  153,
  138,  138,  139,  139,  136,  136,  137,  137,
  142,  142,  143,  143,  140,  140,  141,  141,
  213,  209,  221,  217,  197,  193,  205,  201,
  245,  241,  253,  249,  229,  225,  237,  233,
  170,  168,  174,  172,  162,  160,  166,  164,
  186,  184,  190,  188,  178,  176,  182,  180,
  129,  129,  129,  129,  129,  129,  129,  129,
  129,  129,  129,  129,  129,  129,  129,  129,
  128,  128,  128,  128,  128,  128,  128,  128,
  128,  128,  128,  128,  128,  128,  128,  128,
  133,  133,  133,  133,  132,  132,  132,  132,
  135,  135,  135,  135,  134,  134,  134,  134,
  130,  130,  130,  130,  130,  130,  130,  130,
  131,  131,  131,  131,  131,  131,  131,  131,
};

static uint8_t u8_to_ulaw_tbl[] = {
     0,    0,    0,    0,    0,    1,    1,    1,
     1,    2,    2,    2,    2,    3,    3,    3,
     3,    4,    4,    4,    4,    5,    5,    5,
     5,    6,    6,    6,    6,    7,    7,    7,
     7,    8,    8,    8,    8,    9,    9,    9,
     9,   10,   10,   10,   10,   11,   11,   11,
    11,   12,   12,   12,   12,   13,   13,   13,
    13,   14,   14,   14,   14,   15,   15,   15,
    15,   16,   16,   17,   17,   18,   18,   19,
    19,   20,   20,   21,   21,   22,   22,   23,
    23,   24,   24,   25,   25,   26,   26,   27,
    27,   28,   28,   29,   29,   30,   30,   31,
    31,   32,   33,   34,   35,   36,   37,   38,
    39,   40,   41,   42,   43,   44,   45,   46,
    47,   49,   51,   53,   55,   57,   59,   61,
    63,   66,   70,   74,   78,   84,   92,  104,
   254,  231,  219,  211,  205,  201,  197,  193,
   190,  188,  186,  184,  182,  180,  178,  176,
   175,  174,  173,  172,  171,  170,  169,  168,
   167,  166,  165,  164,  163,  162,  161,  160,
   159,  159,  158,  158,  157,  157,  156,  156,
   155,  155,  154,  154,  153,  153,  152,  152,
   151,  151,  150,  150,  149,  149,  148,  148,
   147,  147,  146,  146,  145,  145,  144,  144,
   143,  143,  143,  143,  142,  142,  142,  142,
   141,  141,  141,  141,  140,  140,  140,  140,
   139,  139,  139,  139,  138,  138,  138,  138,
   137,  137,  137,  137,  136,  136,  136,  136,
   135,  135,  135,  135,  134,  134,  134,  134,
   133,  133,  133,  133,  132,  132,  132,  132,
   131,  131,  131,  131,  130,  130,  130,  130,
   129,  129,  129,  129,  128,  128,  128,  128,
};

static uint8_t u8_to_alaw_tbl[] = {
   42,   42,   42,   42,   42,   43,   43,   43,
   43,   40,   40,   40,   40,   41,   41,   41,
   41,   46,   46,   46,   46,   47,   47,   47,
   47,   44,   44,   44,   44,   45,   45,   45,
   45,   34,   34,   34,   34,   35,   35,   35,
   35,   32,   32,   32,   32,   33,   33,   33,
   33,   38,   38,   38,   38,   39,   39,   39,
   39,   36,   36,   36,   36,   37,   37,   37,
   37,   58,   58,   59,   59,   56,   56,   57,
   57,   62,   62,   63,   63,   60,   60,   61,
   61,   50,   50,   51,   51,   48,   48,   49,
   49,   54,   54,   55,   55,   52,   52,   53,
   53,   10,   11,    8,    9,   14,   15,   12,
   13,    2,    3,    0,    1,    6,    7,    4,
    5,   24,   30,   28,   18,   16,   22,   20,
  106,  110,   98,  102,  122,  114,   75,   90,
  213,  197,  245,  253,  229,  225,  237,  233,
  149,  151,  145,  147,  157,  159,  153,  155,
  133,  132,  135,  134,  129,  128,  131,  130,
  141,  140,  143,  142,  137,  136,  139,  138,
  181,  181,  180,  180,  183,  183,  182,  182,
  177,  177,  176,  176,  179,  179,  178,  178,
  189,  189,  188,  188,  191,  191,  190,  190,
  185,  185,  184,  184,  187,  187,  186,  186,
  165,  165,  165,  165,  164,  164,  164,  164,
  167,  167,  167,  167,  166,  166,  166,  166,
  161,  161,  161,  161,  160,  160,  160,  160,
  163,  163,  163,  163,  162,  162,  162,  162,
  173,  173,  173,  173,  172,  172,  172,  172,
  175,  175,  175,  175,  174,  174,  174,  174,
  169,  169,  169,  169,  168,  168,  168,  168,
  171,  171,  171,  171,  170,  170,  170,  170,
};

static int
feed_table_8(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int j, sign, k;
	uint8_t *tbl = (uint8_t *)f->data;

	if (count < PCM_8_BPS)
		return (0);

	k = FEEDER_FEED(f->source, c, b, count, source);
	if (k < PCM_8_BPS)
		return (0);

	j = k;
	sign = (f->desc->out & AFMT_SIGNED) ? 0x80 : 0x00;

	do {
		j--;
		b[j] = tbl[b[j]] ^ sign;
	} while (j != 0);

	return (k);
}

static int
feed_table_16(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int i, j, sign, k;
	uint8_t *tbl = (uint8_t *)f->data;

	if (count < PCM_16_BPS)
		return (0);

	k = FEEDER_FEED(f->source, c, b, count >> 1, source);
	if (k < PCM_8_BPS)
		return (0);

	i = k;
	k <<= 1;
	j = k;
	sign = (f->desc->out & AFMT_SIGNED) ? 0x80 : 0x00;

	if (f->desc->out & AFMT_BIGENDIAN) {
		do {
			b[--j] = 0;
			b[--j] = tbl[b[--i]] ^ sign;
		} while (i != 0);
	} else {
		do {
			b[--j] = tbl[b[--i]] ^ sign;
			b[--j] = 0;
		} while (i != 0);
	}

	return (k);
}

static int
feed_table_xlaw(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int j, sign, k;
	uint8_t *tbl = (uint8_t *)f->data;

	if (count < PCM_8_BPS)
		return (0);

	k = FEEDER_FEED(f->source, c, b, count, source);
	if (k < PCM_8_BPS)
		return (0);

	j = k ;
	sign = (f->desc->in & AFMT_SIGNED) ? 0x80 : 0x00;

	do {
		j--;
		b[j] = tbl[b[j] ^ sign];
	} while (j != 0);

	return (k);
}

static struct pcm_feederdesc feeder_ulawto8_desc[] = {
	{FEEDER_FMT, AFMT_MU_LAW, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_MU_LAW, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_ulawto8_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_table_8),
	{0, 0}
};
FEEDER_DECLARE(feeder_ulawto8, 0, ulaw_to_u8_tbl);

static struct pcm_feederdesc feeder_alawto8_desc[] = {
	{FEEDER_FMT, AFMT_A_LAW, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_A_LAW, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_alawto8_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_table_8),
	{0, 0}
};
FEEDER_DECLARE(feeder_alawto8, 0, alaw_to_u8_tbl);

static struct pcm_feederdesc feeder_ulawto16_desc[] = {
	{FEEDER_FMT, AFMT_MU_LAW, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_MU_LAW, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_MU_LAW, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_MU_LAW, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_ulawto16_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_table_16),
	{0, 0}
};
FEEDER_DECLARE(feeder_ulawto16, 0, ulaw_to_u8_tbl);

static struct pcm_feederdesc feeder_alawto16_desc[] = {
	{FEEDER_FMT, AFMT_A_LAW, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_A_LAW, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_A_LAW, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_A_LAW, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_alawto16_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_table_16),
	{0, 0}
};
FEEDER_DECLARE(feeder_alawto16, 0, alaw_to_u8_tbl);

static struct pcm_feederdesc feeder_8toulaw_desc[] = {
	{FEEDER_FMT, AFMT_U8, AFMT_MU_LAW, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_MU_LAW | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_MU_LAW, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_MU_LAW | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_8toulaw_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_table_xlaw),
	{0, 0}
};
FEEDER_DECLARE(feeder_8toulaw, 0, u8_to_ulaw_tbl);

static struct pcm_feederdesc feeder_8toalaw_desc[] = {
	{FEEDER_FMT, AFMT_U8, AFMT_A_LAW, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_A_LAW | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_A_LAW, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_A_LAW | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_8toalaw_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_table_xlaw),
	{0, 0}
};
FEEDER_DECLARE(feeder_8toalaw, 0, u8_to_alaw_tbl);

/*
 * All conversion done in byte level to preserve endianess.
 */

#define FEEDFMT_SWAP_SIGN(f)	(((((f)->desc->in & AFMT_SIGNED) == 0) !=	\
				(((f)->desc->out & AFMT_SIGNED) == 0))		\
				? 0x80 : 0x00)

/*
 * Bit conversion
 */

#define FBIT_DATA(i, o, c)	((intptr_t)((((c) & 0xf) << 6) | \
				(((i) & 0x7) << 3) | ((o) & 0x7)))
#define FBIT_OUTBPS(m)		((m) & 0x7)
#define FBIT_INBPS(m)		FBIT_OUTBPS((m) >> 3)
#define FBIT_CHANNELS(m)	(((m) >> 6) & 0xf)

static int
feed_updownbit_init(struct pcm_feeder *f)
{
	int ibps, obps, channels;

	if (f->desc->in == f->desc->out || (f->desc->in & AFMT_STEREO) !=
	    (f->desc->out & AFMT_STEREO))
		return (-1);

	channels = (f->desc->in & AFMT_STEREO) ? 2 : 1;

	if (f->desc->in & AFMT_32BIT)
		ibps = PCM_32_BPS;
	else if (f->desc->in & AFMT_24BIT)
		ibps = PCM_24_BPS;
	else if (f->desc->in & AFMT_16BIT)
		ibps = PCM_16_BPS;
	else
		ibps = PCM_8_BPS;

	if (f->desc->out & AFMT_32BIT)
		obps = PCM_32_BPS;
	else if (f->desc->out & AFMT_24BIT)
		obps = PCM_24_BPS;
	else if (f->desc->out & AFMT_16BIT)
		obps = PCM_16_BPS;
	else
		obps = PCM_8_BPS;

	f->data = (void *)FBIT_DATA(ibps, obps, channels);

	return (0);
}

static int
feed_upbit(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int i, j, k, sign, ibps, ialign, obps, oalign, pad;
	uint8_t *src, *dst;

	ibps = FBIT_INBPS((intptr_t)f->data);
	obps = FBIT_OUTBPS((intptr_t)f->data);

	ialign = ibps * FBIT_CHANNELS((intptr_t)f->data);
	oalign = obps * FBIT_CHANNELS((intptr_t)f->data);

	if (count < oalign)
		return (0);

	k = FEEDER_FEED(f->source, c, b, (count / oalign) * ialign, source);
	if (k < ialign)
		return (0);

	k -= k % ialign;
	j = (k / ibps) * obps;
	pad = obps - ibps;
	src = b + k;
	dst = b + j;
	sign = FEEDFMT_SWAP_SIGN(f);

	if (f->desc->out & AFMT_BIGENDIAN) {
		do {
			i = pad;
			do {
				*--dst = 0;
			} while (--i != 0);
			i = ibps;
			while (--i != 0)
				*--dst = *--src;
			*--dst = *--src ^ sign;
		} while (dst != b);
	} else {
		do {
			*--dst = *--src ^ sign;
			i = ibps;
			while (--i != 0)
				*--dst = *--src;
			i = pad;
			do {
				*--dst = 0;
			} while (--i != 0);
		} while (dst != b);
	}

	return (j);
}

static struct pcm_feederdesc feeder_8to16_desc[] = {
	{FEEDER_FMT, AFMT_U8, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_8to16_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_upbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_8to16, 0, NULL);

static struct pcm_feederdesc feeder_8to24_desc[] = {
	{FEEDER_FMT, AFMT_U8, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_8to24_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_upbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_8to24, 0, NULL);

static struct pcm_feederdesc feeder_8to32_desc[] = {
	{FEEDER_FMT, AFMT_U8, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U8, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_8to32_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_upbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_8to32, 0, NULL);

static struct pcm_feederdesc feeder_16to24_desc[] = {
	{FEEDER_FMT, AFMT_U16_LE, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_LE, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_16to24_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_upbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_16to24, 0, NULL);

static struct pcm_feederdesc feeder_16to32_desc[] = {
	{FEEDER_FMT, AFMT_U16_LE, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_LE, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_16to32_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_upbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_16to32, 0, NULL);

static struct pcm_feederdesc feeder_24to32_desc[] = {
	{FEEDER_FMT, AFMT_U24_LE, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_LE, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_24to32_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_upbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_24to32, 0, NULL);

static int
feed_downbit(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int i, j, k, sign, be, ibps, ialign, obps, oalign,dump;
	uint8_t *src, *dst, *end;
	uint8_t reservoir[FEEDFMT_RESERVOIR];

	ibps = FBIT_INBPS((intptr_t)f->data);
	obps = FBIT_OUTBPS((intptr_t)f->data);

	ialign = ibps * FBIT_CHANNELS((intptr_t)f->data);
	oalign = obps * FBIT_CHANNELS((intptr_t)f->data);

	if (count < oalign)
		return (0);

	dst = b;
	dump = ibps - obps;
	sign = FEEDFMT_SWAP_SIGN(f);
	be = (f->desc->in & AFMT_BIGENDIAN) ? 1 : 0;
	k = count - (count % oalign);

	do {
		if (k < oalign)
			break;

		if (k < ialign) {
			src = reservoir;
			j = ialign;
		} else {
			src = dst;
			j = k;
		}

		j = FEEDER_FEED(f->source, c, src, j - (j % ialign), source);
		if (j < ialign)
			break;

		j -= j % ialign;
		j *= obps;
		j /= ibps;
		end = dst + j;

		if (be != 0) {
			do {
				*dst++ = *src++ ^ sign;
				i = obps;
				while (--i != 0)
					*dst++ = *src++;
				src += dump;
			} while (dst != end);
		} else {
			do {
				src += dump;
				i = obps;
				while (--i != 0)
					*dst++ = *src++;
				*dst++ = *src++ ^ sign;
			} while (dst != end);
		}

		k -= j;
	} while (k != 0);

	return (dst - b);
}

static struct pcm_feederdesc feeder_16to8_desc[] = {
	{FEEDER_FMT, AFMT_U16_LE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_LE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_16to8_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_downbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_16to8, 0, NULL);

static struct pcm_feederdesc feeder_24to8_desc[] = {
	{FEEDER_FMT, AFMT_U24_LE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_LE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_24to8_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_downbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_24to8, 0, NULL);

static struct pcm_feederdesc feeder_24to16_desc[] = {
	{FEEDER_FMT, AFMT_U24_LE, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_LE, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_24to16_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_downbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_24to16, 0, NULL);

static struct pcm_feederdesc feeder_32to8_desc[] = {
	{FEEDER_FMT, AFMT_U32_LE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_LE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_32to8_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_downbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_32to8, 0, NULL);

static struct pcm_feederdesc feeder_32to16_desc[] = {
	{FEEDER_FMT, AFMT_U32_LE, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_LE, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_32to16_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_downbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_32to16, 0, NULL);

static struct pcm_feederdesc feeder_32to24_desc[] = {
	{FEEDER_FMT, AFMT_U32_LE, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_LE, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_32to24_methods[] = {
	KOBJMETHOD(feeder_init,		feed_updownbit_init),
	KOBJMETHOD(feeder_feed,		feed_downbit),
	{0, 0}
};
FEEDER_DECLARE(feeder_32to24, 0, NULL);
/*
 * Bit conversion end
 */

/*
 * Channel conversion (mono -> stereo)
 */
static int
feed_monotostereo(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int bps, i, j, k, l;
	uint8_t v;

	bps = (int)((intptr_t)f->data);
	if (count < (bps << 1))
		return (0);

	j = FEEDER_FEED(f->source, c, b, (count - (count % bps)) >> 1, source);
	if (j < bps)
		return (0);

	j -= j % bps;
	i = j << 1;
	l = i;

	do {
		k = bps;
		do {
			v = b[--j];
			b[--i] = v;
			b[i - bps] = v;
		} while (--k != 0);
		i -= bps;
	} while (i != 0);

	return (l);
}

static struct pcm_feederdesc feeder_monotostereo8_desc[] = {
	{FEEDER_FMT, AFMT_U8, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_MU_LAW, AFMT_MU_LAW | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_A_LAW, AFMT_A_LAW | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_monotostereo8_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_monotostereo),
	{0, 0}
};
FEEDER_DECLARE(feeder_monotostereo8, 0, (void *)PCM_8_BPS);

static struct pcm_feederdesc feeder_monotostereo16_desc[] = {
	{FEEDER_FMT, AFMT_U16_LE, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_U16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_S16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_monotostereo16_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_monotostereo),
	{0, 0}
};
FEEDER_DECLARE(feeder_monotostereo16, 0, (void *)PCM_16_BPS);

static struct pcm_feederdesc feeder_monotostereo24_desc[] = {
	{FEEDER_FMT, AFMT_U24_LE, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_U24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_S24_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_monotostereo24_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_monotostereo),
	{0, 0}
};
FEEDER_DECLARE(feeder_monotostereo24, 0, (void *)PCM_24_BPS);

static struct pcm_feederdesc feeder_monotostereo32_desc[] = {
	{FEEDER_FMT, AFMT_U32_LE, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_U32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_S32_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_monotostereo32_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_monotostereo),
	{0, 0}
};
FEEDER_DECLARE(feeder_monotostereo32, 0, (void *)PCM_32_BPS);
/*
 * Channel conversion (mono -> stereo) end
 */

/*
 * Channel conversion (stereo -> mono)
 */
#define FEEDER_FMT_STEREODOWNMIX(FMTBIT, FMT_INTCAST, SIGN,			\
						SIGNS, ENDIAN, ENDIANS)		\
static void									\
SIGNS##FMTBIT##ENDIANS##_stereodownmix(uint8_t *dst, uint8_t *sx, uint8_t *sy)	\
{										\
	int32_t v;								\
										\
	v = ((FMT_INTCAST)PCM_READ_##SIGN##FMTBIT##_##ENDIAN(sx) +		\
	    PCM_READ_##SIGN##FMTBIT##_##ENDIAN(sy)) >> 1;			\
	PCM_WRITE_##SIGN##FMTBIT##_##ENDIAN(dst, v);				\
}

FEEDER_FMT_STEREODOWNMIX(8, int32_t, S, s, NE, ne);
FEEDER_FMT_STEREODOWNMIX(16, int32_t, S, s, LE, le);
FEEDER_FMT_STEREODOWNMIX(24, int32_t, S, s, LE, le);
FEEDER_FMT_STEREODOWNMIX(32, intpcm_t, S, s, LE, le);
FEEDER_FMT_STEREODOWNMIX(16, int32_t, S, s, BE, be);
FEEDER_FMT_STEREODOWNMIX(24, int32_t, S, s, BE, be);
FEEDER_FMT_STEREODOWNMIX(32, intpcm_t, S, s, BE, be);
FEEDER_FMT_STEREODOWNMIX(8, int32_t, U, u, NE, ne);
FEEDER_FMT_STEREODOWNMIX(16, int32_t, U, u, LE, le);
FEEDER_FMT_STEREODOWNMIX(24, int32_t, U, u, LE, le);
FEEDER_FMT_STEREODOWNMIX(32, intpcm_t, U, u, LE, le);
FEEDER_FMT_STEREODOWNMIX(16, int32_t, U, u, BE, be);
FEEDER_FMT_STEREODOWNMIX(24, int32_t, U, u, BE, be);
FEEDER_FMT_STEREODOWNMIX(32, intpcm_t, U, u, BE, be);

static void
ulaw_stereodownmix(uint8_t *dst, uint8_t *sx, uint8_t *sy)
{
	uint8_t v;

	v = ((uint32_t)ulaw_to_u8_tbl[*sx] + ulaw_to_u8_tbl[*sy]) >> 1;
	*dst = u8_to_ulaw_tbl[v];
}

static void
alaw_stereodownmix(uint8_t *dst, uint8_t *sx, uint8_t *sy)
{
	uint8_t v;

	v = ((uint32_t)alaw_to_u8_tbl[*sx] + alaw_to_u8_tbl[*sy]) >> 1;
	*dst = u8_to_alaw_tbl[v];
}

typedef void (*feed_fmt_stereodownmix_filter)(uint8_t *,
						uint8_t *, uint8_t *);

struct feed_fmt_stereodownmix_info {
	uint32_t format;
	int bps;
	feed_fmt_stereodownmix_filter func[2];
};

static struct feed_fmt_stereodownmix_info feed_fmt_stereodownmix_tbl[] = {
	{ AFMT_S8,     PCM_8_BPS,  { NULL, s8ne_stereodownmix  }},
	{ AFMT_S16_LE, PCM_16_BPS, { NULL, s16le_stereodownmix }},
	{ AFMT_S16_BE, PCM_16_BPS, { NULL, s16be_stereodownmix }},
	{ AFMT_S24_LE, PCM_24_BPS, { NULL, s24le_stereodownmix }},
	{ AFMT_S24_BE, PCM_24_BPS, { NULL, s24be_stereodownmix }},
	{ AFMT_S32_LE, PCM_32_BPS, { NULL, s32le_stereodownmix }},
	{ AFMT_S32_BE, PCM_32_BPS, { NULL, s32be_stereodownmix }},
	{ AFMT_U8,     PCM_8_BPS,  { NULL, u8ne_stereodownmix  }},
	{ AFMT_A_LAW,  PCM_8_BPS,  { NULL, alaw_stereodownmix  }},
	{ AFMT_MU_LAW, PCM_8_BPS,  { NULL, ulaw_stereodownmix  }},
	{ AFMT_U16_LE, PCM_16_BPS, { NULL, u16le_stereodownmix }},
	{ AFMT_U16_BE, PCM_16_BPS, { NULL, u16be_stereodownmix }},
	{ AFMT_U24_LE, PCM_24_BPS, { NULL, u24le_stereodownmix }},
	{ AFMT_U24_BE, PCM_24_BPS, { NULL, u24be_stereodownmix }},
	{ AFMT_U32_LE, PCM_32_BPS, { NULL, u32le_stereodownmix }},
	{ AFMT_U32_BE, PCM_32_BPS, { NULL, u32be_stereodownmix }},
};

#define FSM_DATA(i, j)	((intptr_t)((((i) & 0x1f) << 1) | ((j) & 0x1)))
#define FSM_INFOIDX(m)	(((m) >> 1) & 0x1f)
#define FSM_FUNCIDX(m)	((m) & 0x1)

static int
feed_stereotomono_init(struct pcm_feeder *f)
{
	int i, funcidx;

	if (!(f->desc->in & AFMT_STEREO) || (f->desc->out & AFMT_STEREO))
		return (-1);

	funcidx = (feeder_fmt_stereodownmix != 0) ? 1 : 0;

	for (i = 0; i < sizeof(feed_fmt_stereodownmix_tbl) /
	    sizeof(feed_fmt_stereodownmix_tbl[0]); i++) {
		if (f->desc->out == feed_fmt_stereodownmix_tbl[i].format) {
			f->data = (void *)FSM_DATA(i, funcidx);
			return (0);
		}
	}

	return (-1);
}

static int
feed_stereotomono(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	struct feed_fmt_stereodownmix_info *info;
	feed_fmt_stereodownmix_filter stereodownmix;
	int i, j, k, ibps, obps;
	uint8_t *src, *dst, *end;
	uint8_t reservoir[FEEDFMT_RESERVOIR];

	info = &feed_fmt_stereodownmix_tbl[FSM_INFOIDX((intptr_t)f->data)];
	obps = info->bps;

	if (count < obps)
		return (0);

	stereodownmix = info->func[FSM_FUNCIDX((intptr_t)f->data)];
	ibps = obps << 1;
	dst = b;
	k = count - (count % obps);

	do {
		if (k < obps)
			break;

		if (k < ibps) {
			src = reservoir;
			j = ibps;
		} else {
			src = dst;
			j = k;
		}

		j = FEEDER_FEED(f->source, c, src, j - (j % ibps), source);
		if (j < ibps)
			break;

		j -= j % ibps;
		j >>= 1;
		end = dst + j;

		if (stereodownmix != NULL) {
			do {
				stereodownmix(dst, src, src + obps);
				dst += obps;
				src += ibps;
			} while (dst != end);
		} else {
			do {
				i = obps;
				do {
					*dst++ = *src++;
				} while (--i != 0);
				src += obps;
			} while (dst != end);
		}

		k -= j;
	} while (k != 0);

	return (dst - b);
}

static struct pcm_feederdesc feeder_stereotomono8_desc[] = {
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_MU_LAW, 0},
	{FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_A_LAW, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_stereotomono8_methods[] = {
	KOBJMETHOD(feeder_init,		feed_stereotomono_init),
	KOBJMETHOD(feeder_feed,		feed_stereotomono),
	{0, 0}
};
FEEDER_DECLARE(feeder_stereotomono8, 0, NULL);

static struct pcm_feederdesc feeder_stereotomono16_desc[] = {
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_BE, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_stereotomono16_methods[] = {
	KOBJMETHOD(feeder_init,		feed_stereotomono_init),
	KOBJMETHOD(feeder_feed,		feed_stereotomono),
	{0, 0}
};
FEEDER_DECLARE(feeder_stereotomono16, 0, NULL);

static struct pcm_feederdesc feeder_stereotomono24_desc[] = {
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_S24_BE, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_stereotomono24_methods[] = {
	KOBJMETHOD(feeder_init,		feed_stereotomono_init),
	KOBJMETHOD(feeder_feed,		feed_stereotomono),
	{0, 0}
};
FEEDER_DECLARE(feeder_stereotomono24, 0, NULL);

static struct pcm_feederdesc feeder_stereotomono32_desc[] = {
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_S32_BE, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_stereotomono32_methods[] = {
	KOBJMETHOD(feeder_init,		feed_stereotomono_init),
	KOBJMETHOD(feeder_feed,		feed_stereotomono),
	{0, 0}
};
FEEDER_DECLARE(feeder_stereotomono32, 0, NULL);
/*
 * Channel conversion (stereo -> mono) end
 */

/*
 * Sign conversion
 */
static int
feed_sign(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int i, j, bps, ofs;

	bps = (int)((intptr_t)f->data);
	if (count < bps)
		return (0);

	i = FEEDER_FEED(f->source, c, b, count - (count % bps), source);
	if (i < bps)
		return (0);

	i -= i % bps;
	j = i;
	ofs = (f->desc->in & AFMT_BIGENDIAN) ? bps : 1;

	do {
		b[i - ofs] ^= 0x80;
		i -= bps;
	} while (i != 0);

	return (j);
}
static struct pcm_feederdesc feeder_sign8_desc[] = {
	{FEEDER_FMT, AFMT_U8, AFMT_S8, 0},
	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S8, AFMT_U8, 0},
	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_sign8_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_sign),
	{0, 0}
};
FEEDER_DECLARE(feeder_sign8, 0, (void *)PCM_8_BPS);

static struct pcm_feederdesc feeder_sign16_desc[] = {
	{FEEDER_FMT, AFMT_U16_LE, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_sign16_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_sign),
	{0, 0}
};
FEEDER_DECLARE(feeder_sign16, 0, (void *)PCM_16_BPS);

static struct pcm_feederdesc feeder_sign24_desc[] = {
	{FEEDER_FMT, AFMT_U24_LE, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_sign24_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_sign),
	{0, 0}
};
FEEDER_DECLARE(feeder_sign24, 0, (void *)PCM_24_BPS);

static struct pcm_feederdesc feeder_sign32_desc[] = {
	{FEEDER_FMT, AFMT_U32_LE, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_sign32_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_sign),
	{0, 0}
};
FEEDER_DECLARE(feeder_sign32, 0, (void *)PCM_32_BPS);

/*
 * Endian conversion
 */
static int
feed_endian(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
			uint32_t count, void *source)
{
	int i, j, k, bps;
	uint8_t *buf, v;

	bps = (int)((intptr_t)f->data);
	if (count < bps)
		return (0);

	k = FEEDER_FEED(f->source, c, b, count - (count % bps), source);
	if (k < bps)
		return (0);

	k -= k % bps;
	j = bps >> 1;
	buf = b + k;

	do {
		buf -= bps;
		i = j;
		do {
			v = buf[--i];
			buf[i] = buf[bps - i - 1];
			buf[bps - i - 1] = v;
		} while (i != 0);
	} while (buf != b);

	return (k);
}
static struct pcm_feederdesc feeder_endian16_desc[] = {
	{FEEDER_FMT, AFMT_U16_LE, AFMT_U16_BE, 0},
	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_LE, AFMT_S16_BE, 0},
	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U16_BE, AFMT_U16_LE, 0},
	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S16_BE, AFMT_S16_LE, 0},
	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_endian16_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_endian),
	{0, 0}
};
FEEDER_DECLARE(feeder_endian16, 0, (void *)PCM_16_BPS);

static struct pcm_feederdesc feeder_endian24_desc[] = {
	{FEEDER_FMT, AFMT_U24_LE, AFMT_U24_BE, 0},
	{FEEDER_FMT, AFMT_U24_LE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_LE, AFMT_S24_BE, 0},
	{FEEDER_FMT, AFMT_S24_LE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U24_BE, AFMT_U24_LE, 0},
	{FEEDER_FMT, AFMT_U24_BE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S24_BE, AFMT_S24_LE, 0},
	{FEEDER_FMT, AFMT_S24_BE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_endian24_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_endian),
	{0, 0}
};
FEEDER_DECLARE(feeder_endian24, 0, (void *)PCM_24_BPS);

static struct pcm_feederdesc feeder_endian32_desc[] = {
	{FEEDER_FMT, AFMT_U32_LE, AFMT_U32_BE, 0},
	{FEEDER_FMT, AFMT_U32_LE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_LE, AFMT_S32_BE, 0},
	{FEEDER_FMT, AFMT_S32_LE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_U32_BE, AFMT_U32_LE, 0},
	{FEEDER_FMT, AFMT_U32_BE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_FMT, AFMT_S32_BE, AFMT_S32_LE, 0},
	{FEEDER_FMT, AFMT_S32_BE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_endian32_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_endian),
	{0, 0}
};
FEEDER_DECLARE(feeder_endian32, 0, (void *)PCM_32_BPS);
/*
 * Endian conversion end
 */

/*
 * L/R swap conversion
 */
static int
feed_swaplr(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
						uint32_t count, void *source)
{
	int i, j, bps, smpsz;
	uint8_t *buf, v;

	bps = (int)((intptr_t)f->data);
	smpsz = bps << 1;
	if (count < smpsz)
		return (0);

	j = FEEDER_FEED(f->source, c, b, count - (count % smpsz), source);
	if (j < smpsz)
		return (0);

	j -= j % smpsz;
	buf = b + j;

	do {
		buf -= smpsz;
		i = bps;
		do {
			v = buf[--i];
			buf[i] = buf[bps + i];
			buf[bps + i] = v;
		} while (i != 0);
	} while (buf != b);

	return (j);
}

static struct pcm_feederdesc feeder_swaplr8_desc[] = {
	{FEEDER_SWAPLR, AFMT_S8 | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_U8 | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_A_LAW | AFMT_STEREO, AFMT_A_LAW | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_MU_LAW | AFMT_STEREO, AFMT_A_LAW | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_swaplr8_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_swaplr),
	{0, 0}
};
FEEDER_DECLARE(feeder_swaplr8, -1, (void *)PCM_8_BPS);

static struct pcm_feederdesc feeder_swaplr16_desc[] = {
	{FEEDER_SWAPLR, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_U16_BE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_swaplr16_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_swaplr),
	{0, 0}
};
FEEDER_DECLARE(feeder_swaplr16, -1, (void *)PCM_16_BPS);

static struct pcm_feederdesc feeder_swaplr24_desc[] = {
	{FEEDER_SWAPLR, AFMT_S24_LE | AFMT_STEREO, AFMT_S24_LE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_S24_BE | AFMT_STEREO, AFMT_S24_BE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_U24_LE | AFMT_STEREO, AFMT_U24_LE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_U24_BE | AFMT_STEREO, AFMT_U24_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_swaplr24_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_swaplr),
	{0, 0}
};
FEEDER_DECLARE(feeder_swaplr24, -1, (void *)PCM_24_BPS);

static struct pcm_feederdesc feeder_swaplr32_desc[] = {
	{FEEDER_SWAPLR, AFMT_S32_LE | AFMT_STEREO, AFMT_S32_LE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_S32_BE | AFMT_STEREO, AFMT_S32_BE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_U32_LE | AFMT_STEREO, AFMT_U32_LE | AFMT_STEREO, 0},
	{FEEDER_SWAPLR, AFMT_U32_BE | AFMT_STEREO, AFMT_U32_BE | AFMT_STEREO, 0},
	{0, 0, 0, 0},
};
static kobj_method_t feeder_swaplr32_methods[] = {
	KOBJMETHOD(feeder_feed,		feed_swaplr),
	{0, 0}
};
FEEDER_DECLARE(feeder_swaplr32, -1, (void *)PCM_32_BPS);
/*
 * L/R swap conversion end
 */