xconvert.c

xmms-1.2.10.tar.gz学习使用的就下吧

}

static int convert_mono_to_stereo_16(struct xmms_convert_buffers* buf, void **data, int length)
{
	return convert_mono_to_stereo(buf, data, length, TRUE);
}

static int convert_stereo_to_mono_u8(struct xmms_convert_buffers* buf, void **data, int length)
{
	guint8 *output = *data, *input = *data;
	int i;
	for (i = 0; i < length / 2; i++)
	{
		guint16 tmp;
		tmp = *input++;
		tmp += *input++;
		*output++ = tmp / 2;
	}
	return length / 2;
}
static int convert_stereo_to_mono_s8(struct xmms_convert_buffers* buf, void **data, int length)
{
	gint8 *output = *data, *input = *data;
	int i;
	for (i = 0; i < length / 2; i++)
	{
		gint16 tmp;
		tmp = *input++;
		tmp += *input++;
		*output++ = tmp / 2;
	}
	return length / 2;
}
static int convert_stereo_to_mono_u16le(struct xmms_convert_buffers* buf, void **data, int length)
{
	guint16 *output = *data, *input = *data;
	int i;
	for (i = 0; i < length / 4; i++)
	{
		guint32 tmp;
		guint16 stmp;
		tmp = GUINT16_FROM_LE(*input);
		input++;
		tmp += GUINT16_FROM_LE(*input);
		input++;
		stmp = tmp / 2;
		*output++ = GUINT16_TO_LE(stmp);
	}
	return length / 2;
}

static int convert_stereo_to_mono_u16be(struct xmms_convert_buffers* buf, void **data, int length)
{
	guint16 *output = *data, *input = *data;
	int i;
	for (i = 0; i < length / 4; i++)
	{
		guint32 tmp;
		guint16 stmp;
		tmp = GUINT16_FROM_BE(*input);
		input++;
		tmp += GUINT16_FROM_BE(*input);
		input++;
		stmp = tmp / 2;
		*output++ = GUINT16_TO_BE(stmp);
	}
	return length / 2;
}

static int convert_stereo_to_mono_s16le(struct xmms_convert_buffers* buf, void **data, int length)
{
	gint16 *output = *data, *input = *data;
	int i;
	for (i = 0; i < length / 4; i++)
	{
		gint32 tmp;
		gint16 stmp;
		tmp = GINT16_FROM_LE(*input);
		input++;
		tmp += GINT16_FROM_LE(*input);
		input++;
		stmp = tmp / 2;
		*output++ = GINT16_TO_LE(stmp);
	}
	return length / 2;
}

static int convert_stereo_to_mono_s16be(struct xmms_convert_buffers* buf, void **data, int length)
{
	gint16 *output = *data, *input = *data;
	int i;
	for (i = 0; i < length / 4; i++)
	{
		gint32 tmp;
		gint16 stmp;
		tmp = GINT16_FROM_BE(*input);
		input++;
		tmp += GINT16_FROM_BE(*input);
		input++;
		stmp = tmp / 2;
		*output++ = GINT16_TO_BE(stmp);
	}
	return length / 2;
}

convert_channel_func_t xmms_convert_get_channel_func(AFormat fmt, int output, int input)
{
	fmt = unnativize(fmt);

	if (output == input)
		return NULL;

	if (input == 1 && output == 2)
		switch (fmt)
		{
			case FMT_U8:
			case FMT_S8:
				return convert_mono_to_stereo_8;
			case FMT_U16_LE:
			case FMT_U16_BE:
			case FMT_S16_LE:
			case FMT_S16_BE:
				return convert_mono_to_stereo_16;
			default:
				g_warning("Unknown format: %d"
					  "No conversion available.", fmt);
				return NULL;
		}
	if (input == 2 && output == 1)
		switch (fmt)
		{
			case FMT_U8:
				return convert_stereo_to_mono_u8;
			case FMT_S8:
				return convert_stereo_to_mono_s8;
			case FMT_U16_LE:
				return convert_stereo_to_mono_u16le;
			case FMT_U16_BE:
				return convert_stereo_to_mono_u16be;
			case FMT_S16_LE:
				return convert_stereo_to_mono_s16le;
			case FMT_S16_BE:
				return convert_stereo_to_mono_s16be;
			default:
				g_warning("Unknown format: %d.  "
					  "No conversion available.", fmt);
				return NULL;
				
		}

	g_warning("Input has %d channels, soundcard uses %d channels\n"
		  "No conversion is available", input, output);
	return NULL;
}


#define RESAMPLE_STEREO(sample_type, bswap)			\
do {								\
	const int shift = sizeof (sample_type);			\
        int i, in_samples, out_samples, x, delta;		\
	sample_type *inptr = *data, *outptr;			\
	guint nlen = (((length >> shift) * ofreq) / ifreq);	\
	void *nbuf;						\
	if (nlen == 0)						\
		break;						\
	nlen <<= shift;						\
	if (bswap)						\
		convert_swap_endian(NULL, data, length);	\
	nbuf = convert_get_buffer(&buf->freq_buffer, nlen);	\
	outptr = nbuf;						\
	in_samples = length >> shift;				\
        out_samples = nlen >> shift;				\
	delta = (in_samples << 12) / out_samples;		\
	for (x = 0, i = 0; i < out_samples; i++)		\
	{							\
		int x1, frac;					\
		x1 = (x >> 12) << 12;				\
		frac = x - x1;					\
		*outptr++ =					\
			((inptr[(x1 >> 12) << 1] *		\
			  ((1<<12) - frac) +			\
			  inptr[((x1 >> 12) + 1) << 1] *	\
			  frac) >> 12);				\
		*outptr++ =					\
			((inptr[((x1 >> 12) << 1) + 1] *	\
			  ((1<<12) - frac) +			\
			  inptr[(((x1 >> 12) + 1) << 1) + 1] *	\
			  frac) >> 12);				\
		x += delta;					\
	}							\
	if (bswap)						\
		convert_swap_endian(NULL, &nbuf, nlen);		\
	*data = nbuf;						\
	return nlen;						\
} while (0)


#define RESAMPLE_MONO(sample_type, bswap)			\
do {								\
	const int shift = sizeof (sample_type) - 1;		\
        int i, x, delta, in_samples, out_samples;		\
	sample_type *inptr = *data, *outptr;			\
	guint nlen = (((length >> shift) * ofreq) / ifreq);	\
	void *nbuf;						\
	if (nlen == 0)						\
		break;						\
	nlen <<= shift;						\
	if (bswap)						\
		convert_swap_endian(NULL, data, length);	\
	nbuf = convert_get_buffer(&buf->freq_buffer, nlen);	\
	outptr = nbuf;						\
	in_samples = length >> shift;				\
        out_samples = nlen >> shift;				\
	delta = ((length >> shift) << 12) / out_samples;	\
	for (x = 0, i = 0; i < out_samples; i++)		\
	{							\
		int x1, frac;					\
		x1 = (x >> 12) << 12;				\
		frac = x - x1;					\
		*outptr++ =					\
			((inptr[x1 >> 12] * ((1<<12) - frac) +	\
			  inptr[(x1 >> 12) + 1] * frac) >> 12);	\
		x += delta;					\
	}							\
	if (bswap)						\
		convert_swap_endian(NULL, &nbuf, nlen);		\
	*data = nbuf;						\
	return nlen;						\
} while (0)

static int convert_resample_stereo_s16ne(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_STEREO(gint16, FALSE);
	return 0;
}

static int convert_resample_stereo_s16ae(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_STEREO(gint16, TRUE);
	return 0;
}

static int convert_resample_stereo_u16ne(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_STEREO(guint16, FALSE);
	return 0;
}

static int convert_resample_stereo_u16ae(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_STEREO(guint16, TRUE);
	return 0;
}

static int convert_resample_mono_s16ne(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_MONO(gint16, FALSE);
	return 0;
}

static int convert_resample_mono_s16ae(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_MONO(gint16, TRUE);
	return 0;
}

static int convert_resample_mono_u16ne(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_MONO(guint16, FALSE);
	return 0;
}

static int convert_resample_mono_u16ae(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_MONO(guint16, TRUE);
	return 0;
}

static int convert_resample_stereo_u8(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_STEREO(guint8, FALSE);
	return 0;
}

static int convert_resample_mono_u8(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_MONO(guint8, FALSE);
	return 0;
}

static int convert_resample_stereo_s8(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_STEREO(gint8, FALSE);
	return 0;
}

static int convert_resample_mono_s8(struct xmms_convert_buffers* buf, void **data, int length, int ifreq, int ofreq)
{
	RESAMPLE_MONO(gint8, FALSE);
	return 0;
}


convert_freq_func_t xmms_convert_get_frequency_func(AFormat fmt, int channels)
{
	fmt = unnativize(fmt);
	g_message("fmt %d, channels: %d", fmt, channels);

	if (channels < 1 || channels > 2)
	{
		g_warning("Unsupported number of channels: %d.  "
			  "Resample function not available", channels);
		return NULL;
	}
	if ((IS_BIG_ENDIAN && fmt == FMT_U16_BE) ||
	    (!IS_BIG_ENDIAN && fmt == FMT_U16_LE))
	{
		if (channels == 1)
			return convert_resample_mono_u16ne;
		else
			return convert_resample_stereo_u16ne;
	}
	if ((IS_BIG_ENDIAN && fmt == FMT_S16_BE) ||
	    (!IS_BIG_ENDIAN && fmt == FMT_S16_LE))
	{
		if (channels == 1)
			return convert_resample_mono_s16ne;
		else
			return convert_resample_stereo_s16ne;
	}
	if ((!IS_BIG_ENDIAN && fmt == FMT_U16_BE) ||
	    (IS_BIG_ENDIAN && fmt == FMT_U16_LE))
	{
		if (channels == 1)
			return convert_resample_mono_u16ae;
		else
			return convert_resample_stereo_u16ae;
	}
	if ((!IS_BIG_ENDIAN && fmt == FMT_S16_BE) ||
	    (IS_BIG_ENDIAN && fmt == FMT_S16_LE))
	{
		if (channels == 1)
			return convert_resample_mono_s16ae;
		else
			return convert_resample_stereo_s16ae;
	}
	if (fmt == FMT_U8)
	{
		if (channels == 1)
			return convert_resample_mono_u8;
		else
			return convert_resample_stereo_u8;
	}
	if (fmt == FMT_S8)
	{
		if (channels == 1)
			return convert_resample_mono_s8;
		else
			return convert_resample_stereo_s8;
	}
	g_warning("Resample function not available"
		  "Format %d.", fmt);
	return NULL;
}