/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public

    License along with this library; if not, write to the Free

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga

*/

#ifdef SAVE_RCSID

static char rcsid =

 "@(#) $Id$";

#endif

/* Functions for audio drivers to perform runtime conversion of audio format */

#include <stdio.h>

#include "SDL_error.h"

#include "SDL_audio.h"

/* Effectively mix right and left channels into a single channel */

void SDL_ConvertMono(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Sint32 sample;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting to mono\n");

#endif

	switch (format&0x8018) {

		case AUDIO_U8: {

			Uint8 *src, *dst;

			src = cvt->buf;

			dst = cvt->buf;

			for ( i=cvt->len_cvt/2; i; --i ) {

				sample = src[0] + src[1];

				if ( sample > 255 ) {

					*dst = 255;

				} else {

					*dst = sample;

				}

				src += 2;

				dst += 1;

			}

		}

		break;

		case AUDIO_S8: {

			Sint8 *src, *dst;

			src = (Sint8 *)cvt->buf;

			dst = (Sint8 *)cvt->buf;

			for ( i=cvt->len_cvt/2; i; --i ) {

				sample = src[0] + src[1];

				if ( sample > 127 ) {

					*dst = 127;

				} else

				if ( sample < -128 ) {

					*dst = -128;

				} else {

					*dst = sample;

				}

				src += 2;

				dst += 1;

			}

		}

		break;

		case AUDIO_U16: {

			Uint8 *src, *dst;

			src = cvt->buf;

			dst = cvt->buf;

			if ( (format & 0x1000) == 0x1000 ) {

				for ( i=cvt->len_cvt/4; i; --i ) {

					sample = (Uint16)((src[0]<<8)|src[1])+

					         (Uint16)((src[2]<<8)|src[3]);

					if ( sample > 65535 ) {

						dst[0] = 0xFF;

						dst[1] = 0xFF;

					} else {

						dst[1] = (sample&0xFF);

						sample >>= 8;

						dst[0] = (sample&0xFF);

					}

					src += 4;

					dst += 2;

				}

			} else {

				for ( i=cvt->len_cvt/4; i; --i ) {

					sample = (Uint16)((src[1]<<8)|src[0])+

					         (Uint16)((src[3]<<8)|src[2]);

					if ( sample > 65535 ) {

						dst[0] = 0xFF;

						dst[1] = 0xFF;

					} else {

						dst[0] = (sample&0xFF);

						sample >>= 8;

						dst[1] = (sample&0xFF);

					}

					src += 4;

					dst += 2;

				}

			}

		}

		break;

		case AUDIO_S16: {

			Uint8 *src, *dst;

			src = cvt->buf;

			dst = cvt->buf;

			if ( (format & 0x1000) == 0x1000 ) {

				for ( i=cvt->len_cvt/4; i; --i ) {

					sample = (Sint16)((src[0]<<8)|src[1])+

					         (Sint16)((src[2]<<8)|src[3]);

					if ( sample > 32767 ) {

						dst[0] = 0x7F;

						dst[1] = 0xFF;

					} else

					if ( sample < -32768 ) {

						dst[0] = 0x80;

						dst[1] = 0x00;

					} else {

						dst[1] = (sample&0xFF);

						sample >>= 8;

						dst[0] = (sample&0xFF);

					}

					src += 4;

					dst += 2;

				}

			} else {

				for ( i=cvt->len_cvt/4; i; --i ) {

					sample = (Sint16)((src[1]<<8)|src[0])+

					         (Sint16)((src[3]<<8)|src[2]);

					if ( sample > 32767 ) {

						dst[1] = 0x7F;

						dst[0] = 0xFF;

					} else

					if ( sample < -32768 ) {

						dst[1] = 0x80;

						dst[0] = 0x00;

					} else {

						dst[0] = (sample&0xFF);

						sample >>= 8;

						dst[1] = (sample&0xFF);

					}

					src += 4;

					dst += 2;

				}

			}

		}

		break;

	}

	cvt->len_cvt /= 2;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Duplicate a mono channel to both stereo channels */

void SDL_ConvertStereo(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting to stereo\n");

#endif

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

		Uint16 *src, *dst;

		src = (Uint16 *)(cvt->buf+cvt->len_cvt);

		dst = (Uint16 *)(cvt->buf+cvt->len_cvt*2);

		for ( i=cvt->len_cvt/2; i; --i ) {

			dst -= 2;

			src -= 1;

			dst[0] = src[0];

			dst[1] = src[0];

		}

	} else {

		Uint8 *src, *dst;

		src = cvt->buf+cvt->len_cvt;

		dst = cvt->buf+cvt->len_cvt*2;

		for ( i=cvt->len_cvt; i; --i ) {

			dst -= 2;

			src -= 1;

			dst[0] = src[0];

			dst[1] = src[0];

		}

	}

	cvt->len_cvt *= 2;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Convert 8-bit to 16-bit - LSB */

void SDL_Convert16LSB(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Uint8 *src, *dst;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting to 16-bit LSB\n");

#endif

	src = cvt->buf+cvt->len_cvt;

	dst = cvt->buf+cvt->len_cvt*2;

	for ( i=cvt->len_cvt; i; --i ) {

		src -= 1;

		dst -= 2;

		dst[1] = *src;

		dst[0] = 0;

	}

	format = ((format & ~0x0008) | AUDIO_U16LSB);

	cvt->len_cvt *= 2;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Convert 8-bit to 16-bit - MSB */

void SDL_Convert16MSB(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Uint8 *src, *dst;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting to 16-bit MSB\n");

#endif

	src = cvt->buf+cvt->len_cvt;

	dst = cvt->buf+cvt->len_cvt*2;

	for ( i=cvt->len_cvt; i; --i ) {

		src -= 1;

		dst -= 2;

		dst[0] = *src;

		dst[1] = 0;

	}

	format = ((format & ~0x0008) | AUDIO_U16MSB);

	cvt->len_cvt *= 2;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Convert 16-bit to 8-bit */

void SDL_Convert8(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Uint8 *src, *dst;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting to 8-bit\n");

#endif

	src = cvt->buf;

	dst = cvt->buf;

	if ( (format & 0x1000) != 0x1000 ) { /* Little endian */

		++src;

	}

	for ( i=cvt->len_cvt/2; i; --i ) {

		*dst = *src;

		src += 2;

		dst += 1;

	}

	format = ((format & ~0x9010) | AUDIO_U8);

	cvt->len_cvt /= 2;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Toggle signed/unsigned */

void SDL_ConvertSign(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Uint8 *data;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting audio signedness\n");

#endif

	data = cvt->buf;

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

		if ( (format & 0x1000) != 0x1000 ) { /* Little endian */

			++data;

		}

		for ( i=cvt->len_cvt/2; i; --i ) {

			*data ^= 0x80;

			data += 2;

		}

	} else {

		for ( i=cvt->len_cvt; i; --i ) {

			*data++ ^= 0x80;

		}

	}

	format = (format ^ 0x8000);

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Toggle endianness */

void SDL_ConvertEndian(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Uint8 *data, tmp;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting audio endianness\n");

#endif

	data = cvt->buf;

	for ( i=cvt->len_cvt/2; i; --i ) {

		tmp = data[0];

		data[0] = data[1];

		data[1] = tmp;

		data += 2;

	}

	format = (format ^ 0x1000);

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Convert rate up by multiple of 2 */

void SDL_RateMUL2(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Uint8 *src, *dst;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting audio rate * 2\n");

#endif

	src = cvt->buf+cvt->len_cvt;

	dst = cvt->buf+cvt->len_cvt*2;

	switch (format & 0xFF) {

		case 8:

			for ( i=cvt->len_cvt; i; --i ) {

				src -= 1;

				dst -= 2;

				dst[0] = src[0];

				dst[1] = src[0];

			}

			break;

		case 16:

			for ( i=cvt->len_cvt/2; i; --i ) {

				src -= 2;

				dst -= 4;

				dst[0] = src[0];

				dst[1] = src[1];

				dst[2] = src[0];

				dst[3] = src[1];

			}

			break;

	}

	cvt->len_cvt *= 2;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Convert rate down by multiple of 2 */

void SDL_RateDIV2(SDL_AudioCVT *cvt, Uint16 format)

{

	int i;

	Uint8 *src, *dst;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting audio rate / 2\n");

#endif

	src = cvt->buf;

	dst = cvt->buf;

	switch (format & 0xFF) {

		case 8:

			for ( i=cvt->len_cvt/2; i; --i ) {

				dst[0] = src[0];

				src += 2;

				dst += 1;

			}

			break;

		case 16:

			for ( i=cvt->len_cvt/4; i; --i ) {

				dst[0] = src[0];

				dst[1] = src[1];

				src += 4;

				dst += 2;

			}

			break;

	}

	cvt->len_cvt /= 2;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

/* Very slow rate conversion routine */

void SDL_RateSLOW(SDL_AudioCVT *cvt, Uint16 format)

{

	double ipos;

	int i, clen;

#ifdef DEBUG_CONVERT

	fprintf(stderr, "Converting audio rate * %4.4f\n", 1.0/cvt->rate_incr);

#endif

	clen = (int)((double)cvt->len_cvt / cvt->rate_incr);

	if ( cvt->rate_incr > 1.0 ) {

		switch (format & 0xFF) {

			case 8: {

				Uint8 *output;

				output = cvt->buf;

				ipos = 0.0;

				for ( i=clen; i; --i ) {

					*output = cvt->buf[(int)ipos];

					ipos += cvt->rate_incr;

					output += 1;

				}

			}

			break;

			case 16: {

				Uint16 *output;

				clen &= ~1;

				output = (Uint16 *)cvt->buf;

				ipos = 0.0;

				for ( i=clen/2; i; --i ) {

					*output=((Uint16 *)cvt->buf)[(int)ipos];

					ipos += cvt->rate_incr;

					output += 1;

				}

			}

			break;

		}

	} else {

		switch (format & 0xFF) {

			case 8: {

				Uint8 *output;

				output = cvt->buf+clen;

				ipos = (double)cvt->len_cvt;

				for ( i=clen; i; --i ) {

					ipos -= cvt->rate_incr;

					output -= 1;

					*output = cvt->buf[(int)ipos];

				}

			}

			break;

			case 16: {

				Uint16 *output;

				clen &= ~1;

				output = (Uint16 *)(cvt->buf+clen);

				ipos = (double)cvt->len_cvt/2;

				for ( i=clen/2; i; --i ) {

					ipos -= cvt->rate_incr;

					output -= 1;

					*output=((Uint16 *)cvt->buf)[(int)ipos];

				}

			}

			break;

		}

	}

	cvt->len_cvt = clen;

	if ( cvt->filters[++cvt->filter_index] ) {

		cvt->filters[cvt->filter_index](cvt, format);

	}

}

int SDL_ConvertAudio(SDL_AudioCVT *cvt)

{

	/* Make sure there's data to convert */

	if ( cvt->buf == NULL ) {

		SDL_SetError("No buffer allocated for conversion");

		return(-1);

	}

	/* Return okay if no conversion is necessary */

	cvt->len_cvt = cvt->len;

	if ( cvt->filters[0] == NULL ) {

		return(0);

	}

	/* Set up the conversion and go! */

	cvt->filter_index = 0;

	cvt->filters[0](cvt, cvt->src_format);

	return(0);

}

/* Creates a set of audio filters to convert from one format to another. 

   Returns -1 if the format conversion is not supported, or 1 if the

   audio filter is set up.

*/

int SDL_BuildAudioCVT(SDL_AudioCVT *cvt,

	Uint16 src_format, Uint8 src_channels, int src_rate,

	Uint16 dst_format, Uint8 dst_channels, int dst_rate)

{

	/* Start off with no conversion necessary */

	cvt->needed = 0;

	cvt->filter_index = 0;

	cvt->filters[0] = NULL;

	cvt->len_mult = 1;

	cvt->len_ratio = 1.0;

	/* First filter:  Endian conversion from src to dst */

	if ( (src_format & 0x1000) != (dst_format & 0x1000)

	     && ((src_format & 0xff) != 8) ) {

		cvt->filters[cvt->filter_index++] = SDL_ConvertEndian;

	}

	/* Second filter: Sign conversion -- signed/unsigned */

	if ( (src_format & 0x8000) != (dst_format & 0x8000) ) {