Attachment #144382 for bug #195561

View | Details | Raw Unified | Return to bug 195561
Collapse All | Expand All




#include "audioconvert/audioconvert.h"

/* Duplicate a mono channel to both stereo channels */
void acConvertStereo(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i;

	if((format & 0xFF) == 16) {

		}
	}

	channels *= 2;
	cvt->len_cvt *= 2;

	if ( cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}

/* Effectively mix right and left channels into a single channel */
void acConvertMono(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i;
	ALint sample;


		}
		break;
	}

	channels /= 2;
	cvt->len_cvt /= 2;

	if ( cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}




#include "audioconvert/audioconvert.h"

/* Convert rate up by multiple of 2 */
void acFreqMUL2(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i, j;
	ALubyte *src, *dst;
	src = (ALubyte *) cvt->buf + cvt->len_cvt;
	dst = (ALubyte *) cvt->buf + cvt->len_cvt * 2;

	case 8:
		if (format == AUDIO_U8) {
			ALubyte *src8 = (ALubyte*) src;
			ALubyte *dst8 = (ALubyte*) dst - channels;
			src8 -= 1;
			dst8 -= 2;
			/* For the first sample to be processed (last sample
			   in the buffer) there's no 'next' sample in the
			   buffer to interpolate against.  So we use a value
			   extrapolated (then dampened) from the previous
			   sample in the buffer; this dampens (but doesn't
			   eliminate :() the 'click' of the first sample. */
			if (cvt->len_cvt >= channels*2) {
				for( i=channels; i; --i) {
					int ex; /* extrapolated sample, damped */
				if ( ex > 255 )
					ex = 255;
				else if ( ex < 0 )
					ex = 0;
				dst8[0] = src8[0];
				dst8[1] = ex;
				for ( i=cvt->len_cvt-1; i; --i ) {
					src8 -= 1;
					dst8 -= 1;
					ex = src8[0] + (src8[0]-(int)src8[-channels])/8;
					if ( ex > 255 )
						ex = 255;
					else if ( ex < 0 )
						ex = 0;
					dst8[0] = src8[0];
					dst8[channels] = ex;
				}
				for ( i=cvt->len_cvt-channels; i; ) {
					dst8 -= channels;
					for( j=channels; j; --j,--i) {
						src8 -= 1;
						dst8 -= 1;
						dst8[0] = src8[0];
						dst8[channels] = (src8[0]+(int)src8[channels])/2;
					}
				}
			} else if (cvt->len_cvt >= channels*1) {
				for( i=channels; i; --i) {
					src8 -= 1;
					dst8 -= 1;
					dst8[0] = src8[0];
					dst8[channels] = src8[0];
				}
			}
		} else if (format == AUDIO_S8) {
			ALbyte *src8 = (ALbyte*) src;
			ALbyte *dst8 = (ALbyte*) dst - channels;
			if (cvt->len_cvt >= channels*2) {
				for( i=channels; i; --i) {
					int ex; /* extrapolated sample, damped */
				int ex; /* extrapolated sample, damped */
				ex = src8[0] + (src8[0]-(int)src8[-1])/8;
				if ( ex > 127 )
					ex = 127;
				else if ( ex < -128 )
					ex = -128;
				dst8[0] = src8[0];
				dst8[1] = ex;
				for ( i=cvt->len_cvt-1; i; --i ) {
					src8 -= 1;
					dst8 -= 1;
					ex = src8[0] + (src8[0]-(int)src8[-channels])/8;
					if ( ex > 127 )
						ex = 127;
					else if ( ex < -128 )
						ex = -128;
					dst8[0] = src8[0];
					dst8[channels] = ex;
				}
				for ( i=cvt->len_cvt-channels; i; ) {
					dst8 -= channels;
					for( j=channels; j; --j,--i) {
						src8 -= 1;
						dst8 -= 1;
						dst8[0] = src8[0];
						dst8[channels] = (src8[0]+(int)src8[channels])/2;
					}
				}
			} else if (cvt->len_cvt >= channels*1) {
				for( i=channels; i; --i) {
					src8 -= 1;
					dst8 -= 1;
					dst8[0] = src8[0];
					dst8[channels] = src8[0];
				}
			}
		}
		break;
	case 16:
		if (format == AUDIO_S16) {
			ALshort *src16 = (ALshort*) src;
			ALshort *dst16 = (ALshort*) dst - channels;
			if (cvt->len_cvt >= channels*4) {
				for ( i=channels; i; --i ) {
					int ex; /* extrapolated sample, damped */
				int ex; /* extrapolated sample, damped */
				ex = src16[0] + (src16[0]-(int)src16[-1])/8;
				if ( ex > 32767 )
					ex = 32767;
				else if ( ex < -32768 )
					ex = -32768;
				dst16[0] = src16[0];
				dst16[1] = ex;
				for ( i=cvt->len_cvt/2-1; i; --i ) {
					src16 -= 1;
					dst16 -= 1;
					ex = src16[0] + (src16[0]-(int)src16[-channels])/8;
					if ( ex > 32767 )
						ex = 32767;
					else if ( ex < -32768 )
						ex = -32768;
					dst16[0] = src16[0];
					dst16[channels] = ex;
				}
				for ( i=cvt->len_cvt/2-channels; i; ) {
					dst16 -= channels;
					for( j=channels; j; --j,--i) {
						src16 -= 1;
						dst16 -= 1;
						dst16[0] = src16[0];
						dst16[channels] = (src16[0]+(int)src16[channels])/2;
					}
				}
			} else if (cvt->len_cvt >= channels*2) {
				for( i=channels; i; --i) {
					src16 -= 1;
					dst16 -= 1;
					dst16[0] = src16[0];
					dst16[channels] = src16[0];
				}
			}
		} else if (format == AUDIO_U16) {
			ALushort *src16 = (ALushort*) src;
			ALushort *dst16 = (ALushort*) dst - channels;
			if (cvt->len_cvt >= channels*4) {
				for( i=channels; i; --i) {
					int ex; /* extrapolated sample, damped */
					ex = src16[0] + (src16[0]-(int)src16[-channels])/8;
				ex = src16[0] + (src16[0]-(int)src16[-1])/8;
				if ( ex > 65535 )
					ex = 65535;
				else if ( ex < 0 )
					ex = 0;
				dst16[0] = src16[0];
				dst16[1] = ex;
				for ( i=cvt->len_cvt/2-1; i; --i ) {
					src16 -= 1;
					dst16 -= 1;
					if ( ex > 65535 )
						ex = 65535;
					else if ( ex < 0 )
						ex = 0;
					dst16[0] = src16[0];
					dst16[channels] = ex;
				}
				for ( i=cvt->len_cvt/2-channels; i; ) {
					dst16 -= channels;
					for( j=channels; j; --j,--i) {
						src16 -= 1;
						dst16 -= 1;
						dst16[0] = src16[0];
						dst16[channels] = (src16[0]+(int)src16[channels])/2;
					}
				}
			} else if (cvt->len_cvt >= channels*2) {
				for( i=channels; i; --i) {
					src16 -= 1;
					dst16 -= 1;
					dst16[0] = src16[0];
					dst16[channels] = src16[0];
				}
			}
		} else {
			/* this is a 16-bit format that doesn't correspond

			   future work. */
			ALushort *src16 = (ALushort*) src;
			ALushort *dst16 = (ALushort*) dst;
			for ( i=cvt->len_cvt/2; i; ) {
				dst16 -= channels;
				for( j=channels; j; --j,--i) {
					src16 -= 1;
					dst16 -= 1;
					dst16[0] = src16[0];
					dst16[channels] = src16[0];
				}
			}
		}
	break;

	cvt->len_cvt *= 2;
	
	if (cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}

/* Convert rate down by multiple of 2 */
void acFreqDIV2(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i, j;
	ALubyte *src, *dst;

	src = cvt->buf;
	dst = cvt->buf;
	switch(format & 0xFF) {
		case 8:
			for ( i=cvt->len_cvt/2; i; ) {
				for ( j=channels; j; --j,--i ) {
					dst[0] = src[0];
					src += 1;
					dst += 1;
				}
				src += channels;
			}
			break;
		case 16:
			for ( i=cvt->len_cvt/4; i; ) {
				for ( j=channels; j; --j,--i ) {
					dst[0] = src[0];
					dst[1] = src[1];
					src += 2;
					dst += 2;
				}
				src += channels*2;
			}
			break;
	}

	cvt->len_cvt /= 2;

	if (cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}

/* Very slow rate conversion routine */
void acFreqSLOW(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	double ipos;
	int i, j, clen;

	clen = (int) ((double)((int)cvt->len_cvt / channels) / cvt->rate_incr);
	if(cvt->rate_incr > 1.0) {
		switch(format & 0xFF) {
			case 8: {
				ALubyte *output = cvt->buf;

				clen *= channels;
				ipos = 0.0;
				for ( i=clen; i; ) {
					for ( j=0; j<channels; ++j,--i ) {
						*output=((ALubyte *)cvt->buf)[(int)ipos * channels + j];
						output += 1;
					}
					ipos += cvt->rate_incr;
					output += 1;
				}
			}
			break;

				ALushort *output;

				clen &= ~1;
				clen *= channels;
				output = (ALushort *) cvt->buf;
				ipos = 0.0;
				for ( i=clen/2; i; ) {
					for ( j=0; j<channels; ++j,--i ) {
						*output=((ALushort *)cvt->buf)[(int)ipos * channels + j];
						output += 1;
					}
					ipos += cvt->rate_incr;
					output += 1;
				}
			}
			break;

			case 8: {
				ALubyte *output;

				clen *= channels;
				output = (ALubyte *) cvt->buf + clen;
				ipos = (double)(cvt->len_cvt / channels);
				for ( i=clen; i; ) {
					for ( j=0; j<channels; ++j,--i ) {
						output -= 1;
						*output=((ALubyte *)cvt->buf)[(int)ipos * channels - j - 1];
					}
					ipos -= cvt->rate_incr;
					output -= 1;
					*output = *((ALubyte *) cvt->buf + (int)ipos);
				}
			}
			break;

				ALushort *output;

				clen &= ~1;
				clen *= channels;
				output = (ALushort *) cvt->buf;
				output += clen / sizeof *output;

				ipos = (double)(cvt->len_cvt/2/channels);
				for ( i=clen/2; i; ) {
					for ( j=0; j<channels; ++j,--i ) {
						output -= 1;
						*output=((ALushort *)cvt->buf)[(int)ipos * channels - j - 1];
					}
					ipos -= cvt->rate_incr;
					output -= 1;
					*output=((ALushort *)cvt->buf)[(int)ipos];
				}
			}
			break;

	cvt->len_cvt = clen;

	if (cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}





#include "audioconvert/audioconvert.h"

void acConvertSign(acAudioCVT *cvt, ALushort format, ALushort channels);
void acConvertEndian(acAudioCVT *cvt, ALushort format, ALushort channels);

/* Toggle signed/unsigned */
void acConvertSign(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i;
	ALubyte *data;


	format = (format ^ 0x8000);

	if (cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}

/* Toggle endianness */
void acConvertEndian(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i;
	ALubyte *data, tmp;


	format = (format ^ 0x1000);

	if (cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}


	cvt->filters[0]   = NULL;
	cvt->len_mult     = 1;
	cvt->len_ratio    = 1.0;
	cvt->src_format   = src_format;
	cvt->dst_format   = dst_format;
	cvt->src_channels = src_channels;
	cvt->dst_channels = dst_channels;

	/* First filter:  Endian conversion from src to dst */
	if((( src_format & 0x1000) != (dst_format & 0x1000)) &&

		ALuint hi_rate, lo_rate;
		int len_mult;
		double len_ratio;
		void (*rate_cvt)(acAudioCVT *, ALushort, ALushort);

		assert(src_rate != 0);



	/* Set up the filter information */
	if(cvt->filter_index != 0) {
		cvt->needed = 1;
		cvt->len    = 0;
		cvt->buf    = NULL;
		cvt->src_format = src_format;
		cvt->dst_format = dst_format;
		cvt->filters[cvt->filter_index] = NULL;
	}



	/* Set up the conversion and go! */
	cvt->filter_index = 0;
	cvt->filters[0](cvt, cvt->src_format, cvt->src_channels);

	return 0;
}




#include "audioconvert/audioconvert.h"

/* Convert 8-bit to 16-bit - LSB */
void acConvert16LSB(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i;
	ALubyte *src, *dst;


	cvt->len_cvt *= 2;

	if ( cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}

/* Convert 8-bit to 16-bit - MSB */
void acConvert16MSB(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i;
	ALubyte *src, *dst;


	cvt->len_cvt *= 2;

	if ( cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}

/* Convert 16-bit to 8-bit */
void acConvert8(acAudioCVT *cvt, ALushort format, ALushort channels)
{
	int i;
	ALubyte *src, *dst;


	cvt->len_cvt /= 2;

	if ( cvt->filters[++cvt->filter_index] ) {
		cvt->filters[cvt->filter_index](cvt, format, channels);
	}
}




	int needed;			/* Set to 1 if conversion possible */
	ALushort src_format;		/* Source audio format */
	ALushort dst_format;		/* Target audio format */
	ALushort src_channels;		/* Source channel count */
	ALushort dst_channels;		/* Target channel count */
	double rate_incr;		/* Rate conversion increment */
	void   *buf;			/* Buffer to hold entire audio data */
	int    len;			/* Length of original audio buffer */
	int    len_cvt;			/* Length of converted audio buffer */
	int    len_mult;		/* buffer must be len*len_mult big */
	double len_ratio; 	/* Given len, final size is len*len_ratio */
	void (*filters[10])(struct _acAudioCVT *cvt, ALushort format, ALushort channels);
	int filter_index;		/* Current audio conversion function */
} acAudioCVT;


#define acFormatBits(fmt)           (fmt & 0xff)

/* bit changes */
void acConvert16MSB(acAudioCVT *cvt, ALushort format, ALushort channels);
void acConvert16LSB(acAudioCVT *cvt, ALushort format, ALushort channels);
void acConvert8(acAudioCVT *cvt, ALushort format, ALushort channels);

/* frequency changes */
void acFreqMUL2(acAudioCVT *cvt, ALushort format, ALushort channels);
void acFreqDIV2(acAudioCVT *cvt, ALushort format, ALushort channels);
void acFreqSLOW(acAudioCVT *cvt, ALushort format, ALushort channels);

/* channel changes */
void acConvertStereo(acAudioCVT *cvt, ALushort format, ALushort channels);
void acConvertMono(acAudioCVT *cvt, ALushort format, ALushort channels);

/* misc */
int   ac_is_wave(void *data);

Return to bug 195561

Lines 14-20 Link Here

(-)src/audioconvert/ac_channels.c (-4 / +9 lines)
14	#include "audioconvert/audioconvert.h"	14	#include "audioconvert/audioconvert.h"
15		15
16	/* Duplicate a mono channel to both stereo channels */	16	/* Duplicate a mono channel to both stereo channels */
17	void acConvertStereo(acAudioCVT *cvt, ALushort format) {	17	void acConvertStereo(acAudioCVT *cvt, ALushort format, ALushort channels)
		18	{
18	int i;	19	int i;
19		20
20	if((format & 0xFF) == 16) {	21	if((format & 0xFF) == 16) {
Lines 44-58 Link Here
44	}	45	}
45	}	46	}
46		47
		48	channels *= 2;
47	cvt->len_cvt *= 2;	49	cvt->len_cvt *= 2;
48		50
49	if ( cvt->filters[++cvt->filter_index] ) {	51	if ( cvt->filters[++cvt->filter_index] ) {
50	cvt->filters[cvt->filter_index](cvt, format);	52	cvt->filters[cvt->filter_index](cvt, format, channels);
51	}	53	}
52	}	54	}
53		55
54	/* Effectively mix right and left channels into a single channel */	56	/* Effectively mix right and left channels into a single channel */
55	void acConvertMono(acAudioCVT *cvt, ALushort format) {	57	void acConvertMono(acAudioCVT *cvt, ALushort format, ALushort channels)
		58	{
56	int i;	59	int i;
57	ALint sample;	60	ALint sample;
58		61
Lines 194-202 Link Here
194	}	197	}
195	break;	198	break;
196	}	199	}
		200
		201	channels /= 2;
197	cvt->len_cvt /= 2;	202	cvt->len_cvt /= 2;
198		203
199	if ( cvt->filters[++cvt->filter_index] ) {	204	if ( cvt->filters[++cvt->filter_index] ) {
200	cvt->filters[cvt->filter_index](cvt, format);	205	cvt->filters[cvt->filter_index](cvt, format, channels);
201	}	206	}
202	}	207	}

Lines 21-31 Link Here

(-)src/audioconvert/ac_helper.c (-13 / +17 lines)
21		21
22	#include "audioconvert/audioconvert.h"	22	#include "audioconvert/audioconvert.h"
23		23
24	void acConvertSign(acAudioCVT *cvt, ALushort format);	24	void acConvertSign(acAudioCVT *cvt, ALushort format, ALushort channels);
25	void acConvertEndian(acAudioCVT *cvt, ALushort format);	25	void acConvertEndian(acAudioCVT *cvt, ALushort format, ALushort channels);
26		26
27	/* Toggle signed/unsigned */	27	/* Toggle signed/unsigned */
28	void acConvertSign(acAudioCVT *cvt, ALushort format) {	28	void acConvertSign(acAudioCVT *cvt, ALushort format, ALushort channels)
		29	{
29	int i;	30	int i;
30	ALubyte *data;	31	ALubyte *data;
31		32
Lines 48-59 Link Here
48	format = (format ^ 0x8000);	49	format = (format ^ 0x8000);
49		50
50	if (cvt->filters[++cvt->filter_index] ) {	51	if (cvt->filters[++cvt->filter_index] ) {
51	cvt->filters[cvt->filter_index](cvt, format);	52	cvt->filters[cvt->filter_index](cvt, format, channels);
52	}	53	}
53	}	54	}
54		55
55	/* Toggle endianness */	56	/* Toggle endianness */
56	void acConvertEndian(acAudioCVT *cvt, ALushort format) {	57	void acConvertEndian(acAudioCVT *cvt, ALushort format, ALushort channels)
		58	{
57	int i;	59	int i;
58	ALubyte *data, tmp;	60	ALubyte *data, tmp;
59		61
Lines 68-74 Link Here
68	format = (format ^ 0x1000);	70	format = (format ^ 0x1000);
69		71
70	if (cvt->filters[++cvt->filter_index] ) {	72	if (cvt->filters[++cvt->filter_index] ) {
71	cvt->filters[cvt->filter_index](cvt, format);	73	cvt->filters[cvt->filter_index](cvt, format, channels);
72	}	74	}
73	}	75	}
74		76
Lines 88-93 Link Here
88	cvt->filters[0] = NULL;	90	cvt->filters[0] = NULL;
89	cvt->len_mult = 1;	91	cvt->len_mult = 1;
90	cvt->len_ratio = 1.0;	92	cvt->len_ratio = 1.0;
		93	cvt->src_format = src_format;
		94	cvt->dst_format = dst_format;
		95	cvt->src_channels = src_channels;
		96	cvt->dst_channels = dst_channels;
91		97
92	/* First filter: Endian conversion from src to dst */	98	/* First filter: Endian conversion from src to dst */
93	if((( src_format & 0x1000) != (dst_format & 0x1000)) &&	99	if((( src_format & 0x1000) != (dst_format & 0x1000)) &&
Lines 159-165 Link Here
159	ALuint hi_rate, lo_rate;	165	ALuint hi_rate, lo_rate;
160	int len_mult;	166	int len_mult;
161	double len_ratio;	167	double len_ratio;
162	void (rate_cvt)(acAudioCVT , ALushort );	168	void (rate_cvt)(acAudioCVT , ALushort, ALushort);
163		169
164	assert(src_rate != 0);	170	assert(src_rate != 0);
165		171
Lines 210-220 Link Here
210		216
211	/* Set up the filter information */	217	/* Set up the filter information */
212	if(cvt->filter_index != 0) {	218	if(cvt->filter_index != 0) {
213	cvt->needed = 1;	219	cvt->needed = 1;
214	cvt->len = 0;	220	cvt->len = 0;
215	cvt->buf = NULL;	221	cvt->buf = NULL;
216	cvt->src_format = src_format;
217	cvt->dst_format = dst_format;
218	cvt->filters[cvt->filter_index] = NULL;	222	cvt->filters[cvt->filter_index] = NULL;
219	}	223	}
220		224
Lines 241-247 Link Here
241		245
242	/* Set up the conversion and go! */	246	/* Set up the conversion and go! */
243	cvt->filter_index = 0;	247	cvt->filter_index = 0;
244	cvt->filters[0](cvt, cvt->src_format);	248	cvt->filters[0](cvt, cvt->src_format, cvt->src_channels);
245		249
246	return 0;	250	return 0;
247	}	251	}

Lines 13-19 Link Here

(-)src/audioconvert/ac_bits.c (-6 / +9 lines)
13	#include "audioconvert/audioconvert.h"	13	#include "audioconvert/audioconvert.h"
14		14
15	/* Convert 8-bit to 16-bit - LSB */	15	/* Convert 8-bit to 16-bit - LSB */
16	void acConvert16LSB( acAudioCVT *cvt, ALushort format ) {	16	void acConvert16LSB(acAudioCVT *cvt, ALushort format, ALushort channels)
		17	{
17	int i;	18	int i;
18	ALubyte src, dst;	19	ALubyte src, dst;
19		20
Lines 30-41 Link Here
30	cvt->len_cvt *= 2;	31	cvt->len_cvt *= 2;
31		32
32	if ( cvt->filters[++cvt->filter_index] ) {	33	if ( cvt->filters[++cvt->filter_index] ) {
33	cvt->filters[cvt->filter_index](cvt, format);	34	cvt->filters[cvt->filter_index](cvt, format, channels);
34	}	35	}
35	}	36	}
36		37
37	/* Convert 8-bit to 16-bit - MSB */	38	/* Convert 8-bit to 16-bit - MSB */
38	void acConvert16MSB(acAudioCVT *cvt, ALushort format) {	39	void acConvert16MSB(acAudioCVT *cvt, ALushort format, ALushort channels)
		40	{
39	int i;	41	int i;
40	ALubyte src, dst;	42	ALubyte src, dst;
41		43
Lines 52-63 Link Here
52	cvt->len_cvt *= 2;	54	cvt->len_cvt *= 2;
53		55
54	if ( cvt->filters[++cvt->filter_index] ) {	56	if ( cvt->filters[++cvt->filter_index] ) {
55	cvt->filters[cvt->filter_index](cvt, format);	57	cvt->filters[cvt->filter_index](cvt, format, channels);
56	}	58	}
57	}	59	}
58		60
59	/* Convert 16-bit to 8-bit */	61	/* Convert 16-bit to 8-bit */
60	void acConvert8(acAudioCVT *cvt, ALushort format) {	62	void acConvert8(acAudioCVT *cvt, ALushort format, ALushort channels)
		63	{
61	int i;	64	int i;
62	ALubyte src, dst;	65	ALubyte src, dst;
63		66
Lines 78-83 Link Here
78	cvt->len_cvt /= 2;	81	cvt->len_cvt /= 2;
79		82
80	if ( cvt->filters[++cvt->filter_index] ) {	83	if ( cvt->filters[++cvt->filter_index] ) {
81	cvt->filters[cvt->filter_index](cvt, format);	84	cvt->filters[cvt->filter_index](cvt, format, channels);
82	}	85	}
83	}	86	}

Lines 15-22 Link Here

(-)src/audioconvert/ac_freq.c (-112 / +171 lines)
15	#include "audioconvert/audioconvert.h"	15	#include "audioconvert/audioconvert.h"
16		16
17	/* Convert rate up by multiple of 2 */	17	/* Convert rate up by multiple of 2 */
18	void acFreqMUL2(acAudioCVT *cvt, ALushort format) {	18	void acFreqMUL2(acAudioCVT *cvt, ALushort format, ALushort channels)
19	int i;	19	{
		20	int i, j;
20	ALubyte src, dst;	21	ALubyte src, dst;
21	src = (ALubyte *) cvt->buf + cvt->len_cvt;	22	src = (ALubyte *) cvt->buf + cvt->len_cvt;
22	dst = (ALubyte ) cvt->buf + cvt->len_cvt 2;	23	dst = (ALubyte ) cvt->buf + cvt->len_cvt 2;
Lines 25-132 Link Here
25	case 8:	26	case 8:
26	if (format == AUDIO_U8) {	27	if (format == AUDIO_U8) {
27	ALubyte src8 = (ALubyte) src;	28	ALubyte src8 = (ALubyte) src;
28	ALubyte dst8 = (ALubyte) dst;	29	ALubyte dst8 = (ALubyte) dst - channels;
29	src8 -= 1;
30	dst8 -= 2;
31	/* For the first sample to be processed (last sample	30	/* For the first sample to be processed (last sample
32	in the buffer) there's no 'next' sample in the	31	in the buffer) there's no 'next' sample in the
33	buffer to interpolate against. So we use a value	32	buffer to interpolate against. So we use a value
34	extrapolated (then dampened) from the previous	33	extrapolated (then dampened) from the previous
35	sample in the buffer; this dampens (but doesn't	34	sample in the buffer; this dampens (but doesn't
36	eliminate :() the 'click' of the first sample. */	35	eliminate :() the 'click' of the first sample. */
37	if (cvt->len_cvt >= 2) {	36	if (cvt->len_cvt >= channels*2) {
38	int ex; /* extrapolated sample, damped */	37	for( i=channels; i; --i) {
39	ex = src8[0] + (src8[0]-(int)src8[-1])/8;	38	int ex; /* extrapolated sample, damped */
40	if ( ex > 255 )
41	ex = 255;
42	else if ( ex < 0 )
43	ex = 0;
44	dst8[0] = src8[0];
45	dst8[1] = ex;
46	for ( i=cvt->len_cvt-1; i; --i ) {
47	src8 -= 1;	39	src8 -= 1;
48	dst8 -= 2;	40	dst8 -= 1;
		41	ex = src8[0] + (src8[0]-(int)src8[-channels])/8;
		42	if ( ex > 255 )
		43	ex = 255;
		44	else if ( ex < 0 )
		45	ex = 0;
49	dst8[0] = src8[0];	46	dst8[0] = src8[0];
50	dst8[1] = (src8[0]+(int)src8[1])/2;	47	dst8[channels] = ex;
51	}	48	}
52	} else if (cvt->len_cvt == 1) {	49	for ( i=cvt->len_cvt-channels; i; ) {
53	dst8[0] = src8[0];	50	dst8 -= channels;
54	dst8[1] = src8[0];	51	for( j=channels; j; --j,--i) {
		52	src8 -= 1;
		53	dst8 -= 1;
		54	dst8[0] = src8[0];
		55	dst8[channels] = (src8[0]+(int)src8[channels])/2;
		56	}
		57	}
		58	} else if (cvt->len_cvt >= channels*1) {
		59	for( i=channels; i; --i) {
		60	src8 -= 1;
		61	dst8 -= 1;
		62	dst8[0] = src8[0];
		63	dst8[channels] = src8[0];
		64	}
55	}	65	}
56	} else if (format == AUDIO_S8) {	66	} else if (format == AUDIO_S8) {
57	ALbyte src8 = (ALbyte) src;	67	ALbyte src8 = (ALbyte) src;
58	ALbyte dst8 = (ALbyte) dst;	68	ALbyte dst8 = (ALbyte) dst - channels;
59	src8 -= 1;	69	if (cvt->len_cvt >= channels*2) {
60	dst8 -= 2;	70	for( i=channels; i; --i) {
61	if (cvt->len_cvt >= 2) {	71	int ex; /* extrapolated sample, damped */
62	int ex; /* extrapolated sample, damped */
63	ex = src8[0] + (src8[0]-(int)src8[-1])/8;
64	if ( ex > 127 )
65	ex = 127;
66	else if ( ex < -128 )
67	ex = -128;
68	dst8[0] = src8[0];
69	dst8[1] = ex;
70	for ( i=cvt->len_cvt-1; i; --i ) {
71	src8 -= 1;	72	src8 -= 1;
72	dst8 -= 2;	73	dst8 -= 1;
		74	ex = src8[0] + (src8[0]-(int)src8[-channels])/8;
		75	if ( ex > 127 )
		76	ex = 127;
		77	else if ( ex < -128 )
		78	ex = -128;
73	dst8[0] = src8[0];	79	dst8[0] = src8[0];
74	dst8[1] = (src8[0]+(int)src8[1])/2;	80	dst8[channels] = ex;
75	}	81	}
76	} else {	82	for ( i=cvt->len_cvt-channels; i; ) {
77	dst8[0] = src8[0];	83	dst8 -= channels;
78	dst8[1] = src8[0];	84	for( j=channels; j; --j,--i) {
		85	src8 -= 1;
		86	dst8 -= 1;
		87	dst8[0] = src8[0];
		88	dst8[channels] = (src8[0]+(int)src8[channels])/2;
		89	}
		90	}
		91	} else if (cvt->len_cvt >= channels*1) {
		92	for( i=channels; i; --i) {
		93	src8 -= 1;
		94	dst8 -= 1;
		95	dst8[0] = src8[0];
		96	dst8[channels] = src8[0];
		97	}
79	}	98	}
80	}	99	}
81	break;	100	break;
82	case 16:	101	case 16:
83	if (format == AUDIO_S16) {	102	if (format == AUDIO_S16) {
84	ALshort src16 = (ALshort) src;	103	ALshort src16 = (ALshort) src;
85	ALshort dst16 = (ALshort) dst;	104	ALshort dst16 = (ALshort) dst - channels;
86	src16 -= 1;	105	if (cvt->len_cvt >= channels*4) {
87	dst16 -= 2;	106	for ( i=channels; i; --i ) {
88	if (cvt->len_cvt >= 4) {	107	int ex; /* extrapolated sample, damped */
89	int ex; /* extrapolated sample, damped */
90	ex = src16[0] + (src16[0]-(int)src16[-1])/8;
91	if ( ex > 32767 )
92	ex = 32767;
93	else if ( ex < -32768 )
94	ex = -32768;
95	dst16[0] = src16[0];
96	dst16[1] = ex;
97	for ( i=cvt->len_cvt/2-1; i; --i ) {
98	src16 -= 1;	108	src16 -= 1;
99	dst16 -= 2;	109	dst16 -= 1;
		110	ex = src16[0] + (src16[0]-(int)src16[-channels])/8;
		111	if ( ex > 32767 )
		112	ex = 32767;
		113	else if ( ex < -32768 )
		114	ex = -32768;
100	dst16[0] = src16[0];	115	dst16[0] = src16[0];
101	dst16[1] = (src16[0]+(int)src16[1])/2;	116	dst16[channels] = ex;
102	}	117	}
103	} else if (cvt->len_cvt == 2) {	118	for ( i=cvt->len_cvt/2-channels; i; ) {
104	dst16[0] = src16[0];	119	dst16 -= channels;
105	dst16[1] = src16[0];	120	for( j=channels; j; --j,--i) {
		121	src16 -= 1;
		122	dst16 -= 1;
		123	dst16[0] = src16[0];
		124	dst16[channels] = (src16[0]+(int)src16[channels])/2;
		125	}
		126	}
		127	} else if (cvt->len_cvt >= channels*2) {
		128	for( i=channels; i; --i) {
		129	src16 -= 1;
		130	dst16 -= 1;
		131	dst16[0] = src16[0];
		132	dst16[channels] = src16[0];
		133	}
106	}	134	}
107	} else if (format == AUDIO_U16) {	135	} else if (format == AUDIO_U16) {
108	ALushort src16 = (ALushort) src;	136	ALushort src16 = (ALushort) src;
109	ALushort dst16 = (ALushort) dst;	137	ALushort dst16 = (ALushort) dst - channels;
110	src16 -= 1;	138	if (cvt->len_cvt >= channels*4) {
111	dst16 -= 2;	139	for( i=channels; i; --i) {
112	if (cvt->len_cvt >= 4) {	140	int ex; /* extrapolated sample, damped */
113	int ex; /* extrapolated sample, damped */	141	ex = src16[0] + (src16[0]-(int)src16[-channels])/8;
114	ex = src16[0] + (src16[0]-(int)src16[-1])/8;
115	if ( ex > 65535 )
116	ex = 65535;
117	else if ( ex < 0 )
118	ex = 0;
119	dst16[0] = src16[0];
120	dst16[1] = ex;
121	for ( i=cvt->len_cvt/2-1; i; --i ) {
122	src16 -= 1;	142	src16 -= 1;
123	dst16 -= 2;	143	dst16 -= 1;
		144	if ( ex > 65535 )
		145	ex = 65535;
		146	else if ( ex < 0 )
		147	ex = 0;
124	dst16[0] = src16[0];	148	dst16[0] = src16[0];
125	dst16[1] = (src16[0]+(int)src16[1])/2;	149	dst16[channels] = ex;
126	}	150	}
127	} else if (cvt->len_cvt == 2) {	151	for ( i=cvt->len_cvt/2-channels; i; ) {
128	dst16[0] = src16[0];	152	dst16 -= channels;
129	dst16[1] = src16[0];	153	for( j=channels; j; --j,--i) {
		154	src16 -= 1;
		155	dst16 -= 1;
		156	dst16[0] = src16[0];
		157	dst16[channels] = (src16[0]+(int)src16[channels])/2;
		158	}
		159	}
		160	} else if (cvt->len_cvt >= channels*2) {
		161	for( i=channels; i; --i) {
		162	src16 -= 1;
		163	dst16 -= 1;
		164	dst16[0] = src16[0];
		165	dst16[channels] = src16[0];
		166	}
130	}	167	}
131	} else {	168	} else {
132	/* this is a 16-bit format that doesn't correspond	169	/* this is a 16-bit format that doesn't correspond
Lines 136-146 Link Here
136	future work. */	173	future work. */
137	ALushort src16 = (ALushort) src;	174	ALushort src16 = (ALushort) src;
138	ALushort dst16 = (ALushort) dst;	175	ALushort dst16 = (ALushort) dst;
139	for ( i=cvt->len_cvt/2; i; --i ) {	176	for ( i=cvt->len_cvt/2; i; ) {
140	src16 -= 1;	177	dst16 -= channels;
141	dst16 -= 2;	178	for( j=channels; j; --j,--i) {
142	dst16[0] = src16[0];	179	src16 -= 1;
143	dst16[1] = src16[0];	180	dst16 -= 1;
		181	dst16[0] = src16[0];
		182	dst16[channels] = src16[0];
		183	}
144	}	184	}
145	}	185	}
146	break;	186	break;
Lines 148-178 Link Here
148	cvt->len_cvt *= 2;	188	cvt->len_cvt *= 2;
149		189
150	if (cvt->filters[++cvt->filter_index] ) {	190	if (cvt->filters[++cvt->filter_index] ) {
151	cvt->filters[cvt->filter_index](cvt, format);	191	cvt->filters[cvt->filter_index](cvt, format, channels);
152	}	192	}
153	}	193	}
154		194
155	/* Convert rate down by multiple of 2 */	195	/* Convert rate down by multiple of 2 */
156	void acFreqDIV2(acAudioCVT *cvt, ALushort format) {	196	void acFreqDIV2(acAudioCVT *cvt, ALushort format, ALushort channels)
157	int i;	197	{
		198	int i, j;
158	ALubyte src, dst;	199	ALubyte src, dst;
159		200
160	src = cvt->buf;	201	src = cvt->buf;
161	dst = cvt->buf;	202	dst = cvt->buf;
162	switch(format & 0xFF) {	203	switch(format & 0xFF) {
163	case 8:	204	case 8:
164	for ( i=cvt->len_cvt/2; i; --i ) {	205	for ( i=cvt->len_cvt/2; i; ) {
165	dst[0] = src[0];	206	for ( j=channels; j; --j,--i ) {
166	src += 2;	207	dst[0] = src[0];
167	dst += 1;	208	src += 1;
		209	dst += 1;
		210	}
		211	src += channels;
168	}	212	}
169	break;	213	break;
170	case 16:	214	case 16:
171	for ( i=cvt->len_cvt/4; i; --i ) {	215	for ( i=cvt->len_cvt/4; i; ) {
172	dst[0] = src[0];	216	for ( j=channels; j; --j,--i ) {
173	dst[1] = src[1];	217	dst[0] = src[0];
174	src += 4;	218	dst[1] = src[1];
175	dst += 2;	219	src += 2;
		220	dst += 2;
		221	}
		222	src += channels*2;
176	}	223	}
177	break;	224	break;
178	}	225	}
Lines 180-206 Link Here
180	cvt->len_cvt /= 2;	227	cvt->len_cvt /= 2;
181		228
182	if (cvt->filters[++cvt->filter_index] ) {	229	if (cvt->filters[++cvt->filter_index] ) {
183	cvt->filters[cvt->filter_index](cvt, format);	230	cvt->filters[cvt->filter_index](cvt, format, channels);
184	}	231	}
185	}	232	}
186		233
187	/* Very slow rate conversion routine */	234	/* Very slow rate conversion routine */
188	void acFreqSLOW(acAudioCVT *cvt, ALushort format) {	235	void acFreqSLOW(acAudioCVT *cvt, ALushort format, ALushort channels)
		236	{
189	double ipos;	237	double ipos;
190	int i, clen;	238	int i, j, clen;
191		239
192	clen = (int) ((double)cvt->len_cvt / cvt->rate_incr);	240	clen = (int) ((double)((int)cvt->len_cvt / channels) / cvt->rate_incr);
193	if(cvt->rate_incr > 1.0) {	241	if(cvt->rate_incr > 1.0) {
194	switch(format & 0xFF) {	242	switch(format & 0xFF) {
195	case 8: {	243	case 8: {
196	ALubyte *output;	244	ALubyte *output = cvt->buf;
197		245
198	output = cvt->buf;	246	clen *= channels;
199	ipos = 0.0;	247	ipos = 0.0;
200	for ( i=clen; i; --i ) {	248	for ( i=clen; i; ) {
201	output = ((ALubyte *) cvt->buf + (int)ipos);	249	for ( j=0; j<channels; ++j,--i ) {
		250	output=((ALubyte )cvt->buf)[(int)ipos * channels + j];
		251	output += 1;
		252	}
202	ipos += cvt->rate_incr;	253	ipos += cvt->rate_incr;
203	output += 1;
204	}	254	}
205	}	255	}
206	break;	256	break;
Lines 209-220 Link Here
209	ALushort *output;	259	ALushort *output;
210		260
211	clen &= ~1;	261	clen &= ~1;
		262	clen *= channels;
212	output = (ALushort *) cvt->buf;	263	output = (ALushort *) cvt->buf;
213	ipos = 0.0;	264	ipos = 0.0;
214	for ( i=clen/2; i; --i ) {	265	for ( i=clen/2; i; ) {
215	output=((ALushort )cvt->buf)[(int)ipos];	266	for ( j=0; j<channels; ++j,--i ) {
		267	output=((ALushort )cvt->buf)[(int)ipos * channels + j];
		268	output += 1;
		269	}
216	ipos += cvt->rate_incr;	270	ipos += cvt->rate_incr;
217	output += 1;
218	}	271	}
219	}	272	}
220	break;	273	break;
Lines 229-240 Link Here
229	case 8: {	282	case 8: {
230	ALubyte *output;	283	ALubyte *output;
231		284
		285	clen *= channels;
232	output = (ALubyte *) cvt->buf + clen;	286	output = (ALubyte *) cvt->buf + clen;
233	ipos = (double)cvt->len_cvt;	287	ipos = (double)(cvt->len_cvt / channels);
234	for ( i=clen; i; --i ) {	288	for ( i=clen; i; ) {
		289	for ( j=0; j<channels; ++j,--i ) {
		290	output -= 1;
		291	output=((ALubyte )cvt->buf)[(int)ipos * channels - j - 1];
		292	}
235	ipos -= cvt->rate_incr;	293	ipos -= cvt->rate_incr;
236	output -= 1;
237	output = ((ALubyte *) cvt->buf + (int)ipos);
238	}	294	}
239	}	295	}
240	break;	296	break;
Lines 243-256 Link Here
243	ALushort *output;	299	ALushort *output;
244		300
245	clen &= ~1;	301	clen &= ~1;
		302	clen *= channels;
246	output = (ALushort *) cvt->buf;	303	output = (ALushort *) cvt->buf;
247	output += clen / sizeof *output;	304	output += clen / sizeof *output;
248		305
249	ipos = (double)cvt->len_cvt/2;	306	ipos = (double)(cvt->len_cvt/2/channels);
250	for ( i=clen/2; i; --i ) {	307	for ( i=clen/2; i; ) {
		308	for ( j=0; j<channels; ++j,--i ) {
		309	output -= 1;
		310	output=((ALushort )cvt->buf)[(int)ipos * channels - j - 1];
		311	}
251	ipos -= cvt->rate_incr;	312	ipos -= cvt->rate_incr;
252	output -= 1;
253	output=((ALushort )cvt->buf)[(int)ipos];
254	}	313	}
255	}	314	}
256	break;	315	break;
Lines 264-269 Link Here
264	cvt->len_cvt = clen;	323	cvt->len_cvt = clen;
265		324
266	if (cvt->filters[++cvt->filter_index] ) {	325	if (cvt->filters[++cvt->filter_index] ) {
267	cvt->filters[cvt->filter_index](cvt, format);	326	cvt->filters[cvt->filter_index](cvt, format, channels);
268	}	327	}
269	}	328	}

Lines 16-28 Link Here

(-)src/audioconvert/audioconvert.h (-9 / +11 lines)
16	int needed; /* Set to 1 if conversion possible */	16	int needed; /* Set to 1 if conversion possible */
17	ALushort src_format; /* Source audio format */	17	ALushort src_format; /* Source audio format */
18	ALushort dst_format; /* Target audio format */	18	ALushort dst_format; /* Target audio format */
		19	ALushort src_channels; /* Source channel count */
		20	ALushort dst_channels; /* Target channel count */
19	double rate_incr; /* Rate conversion increment */	21	double rate_incr; /* Rate conversion increment */
20	void buf; / Buffer to hold entire audio data */	22	void buf; / Buffer to hold entire audio data */
21	int len; /* Length of original audio buffer */	23	int len; /* Length of original audio buffer */
22	int len_cvt; /* Length of converted audio buffer */	24	int len_cvt; /* Length of converted audio buffer */
23	int len_mult; /* buffer must be lenlen_mult big /	25	int len_mult; /* buffer must be lenlen_mult big /
24	double len_ratio; /* Given len, final size is lenlen_ratio /	26	double len_ratio; /* Given len, final size is lenlen_ratio /
25	void (filters[10])(struct _acAudioCVT cvt, ALushort format);	27	void (filters[10])(struct _acAudioCVT cvt, ALushort format, ALushort channels);
26	int filter_index; /* Current audio conversion function */	28	int filter_index; /* Current audio conversion function */
27	} acAudioCVT;	29	} acAudioCVT;
28		30
Lines 47-64 Link Here
47	#define acFormatBits(fmt) (fmt & 0xff)	49	#define acFormatBits(fmt) (fmt & 0xff)
48		50
49	/* bit changes */	51	/* bit changes */
50	void acConvert16MSB(acAudioCVT *cvt, ALushort format);	52	void acConvert16MSB(acAudioCVT *cvt, ALushort format, ALushort channels);
51	void acConvert16LSB(acAudioCVT *cvt, ALushort format);	53	void acConvert16LSB(acAudioCVT *cvt, ALushort format, ALushort channels);
52	void acConvert8(acAudioCVT *cvt, ALushort format);	54	void acConvert8(acAudioCVT *cvt, ALushort format, ALushort channels);
53		55
54	/* frequency changes */	56	/* frequency changes */
55	void acFreqMUL2(acAudioCVT *cvt, ALushort format);	57	void acFreqMUL2(acAudioCVT *cvt, ALushort format, ALushort channels);
56	void acFreqDIV2(acAudioCVT *cvt, ALushort format);	58	void acFreqDIV2(acAudioCVT *cvt, ALushort format, ALushort channels);
57	void acFreqSLOW(acAudioCVT *cvt, ALushort format);	59	void acFreqSLOW(acAudioCVT *cvt, ALushort format, ALushort channels);
58		60
59	/* channel changes */	61	/* channel changes */
60	void acConvertStereo(acAudioCVT *cvt, ALushort format);	62	void acConvertStereo(acAudioCVT *cvt, ALushort format, ALushort channels);
61	void acConvertMono(acAudioCVT *cvt, ALushort format);	63	void acConvertMono(acAudioCVT *cvt, ALushort format, ALushort channels);
62		64
63	/* misc */	65	/* misc */
64	int ac_is_wave(void *data);	66	int ac_is_wave(void *data);