/*
 * Copyright 2000-2006 Ingo Weinhold <ingo_weinhold@gmx.de>
 * Copyright 2008 Stephan Aßmus <superstippi@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT licensce.
 */


#include "AudioFormatConverter.h"

#include <ByteOrder.h>
#include <MediaDefs.h>


//#define TRACE_AUDIO_CONVERTER
#ifdef TRACE_AUDIO_CONVERTER
#	include <stdio.h>
#	define TRACE(x...)	printf(x)
#else
#	define TRACE(x...)
#endif


struct ReadFloat {
	inline int operator()(const void* buffer) const {
		// 0 == mid, -1.0 == bottom, 1.0 == top
		float b = *(float*)buffer;
		if (b < -1.0f)
			b = -1.0f;
		else if (b > 1.0f)
			b = 1.0f;
		return (int)((double)b * (double)0x7fffffff);
	}
};

struct ReadInt {
	inline int operator()(const void* buffer) const {
		// 0 == mid, 0x80000001 == bottom, 0x7fffffff == top
		int b = *(int*)buffer;
		if (b == INT_MIN)
			b++;
		return b;
	}
};

struct ReadShort {
	inline int operator()(const void* buffer) const {
		// 0 == mid, -32767 == bottom, +32767
		short b = *(short*)buffer;
		if (b == -32768)
			b++;
		return int(int64(b) * 0x7fffffff / 32767);
	}
};

struct ReadUChar {
	inline int operator()(const void* buffer) const {
		// 128 == mid, 1 == bottom, 255 == top
		uchar b = *(uchar*)buffer;
		if (b == 0)
			b++;
		return int((int64(b) - 0x80) * 0x7fffffff / 127);
	}
};

struct ReadChar {
	inline int operator()(const void* buffer) const {
		// 0 == mid, -127 == bottom, +127 == top
		char b = *(char*)buffer;
		if (b == 0)
			b++;
		return int(int64(b) * 0x7fffffff / 127);
	}
};

struct WriteFloat {
	inline void operator()(void* buffer, int value) const {
		*(float*)buffer = (double)value / (double)0x7fffffff;
	}

};

struct WriteInt {
	inline void operator()(void* buffer, int value) const {
		*(int*)buffer = value;
	}
};

struct WriteShort {
	inline void operator()(void* buffer, int value) const {
		*(short*)buffer = (short)(value / (int)0x10000);
	}
};

struct WriteUChar {
	inline void operator()(void* buffer, int value) const {
		*(uchar*)buffer = (uchar)(value / (int)0x1000000 + 128);
	}
};

struct WriteChar {
	inline void operator()(void* buffer, int value) const {
		*(char*)buffer = (char)(value / (int)0x1000000);
	}
};


template<typename ReadT, typename WriteT>
static void
convert(const ReadT& read, const WriteT& write,
		const char* inBuffer, char* outBuffer, int32 frames,
		int32 inSampleSize, int32 outSampleSize, int32 channelCount)
{
	for (int32 i = 0; i < frames; i++) {
		for (int32 c = 0; c < channelCount; c++) {
			write(outBuffer, read(inBuffer));
			inBuffer += inSampleSize;
			outBuffer += outSampleSize;
		}
	}
}


static void
swap_sample_byte_order(void* buffer, uint32 format, size_t length)
{
	type_code type = B_ANY_TYPE;
	switch (format) {
		case media_raw_audio_format::B_AUDIO_FLOAT:
			type = B_FLOAT_TYPE;
			break;
		case media_raw_audio_format::B_AUDIO_INT:
			type = B_INT32_TYPE;
			break;
		case media_raw_audio_format::B_AUDIO_SHORT:
			type = B_INT16_TYPE;
			break;
		case media_raw_audio_format::B_AUDIO_UCHAR:
			break;
		case media_raw_audio_format::B_AUDIO_CHAR:
			break;
	}
	if (type != B_ANY_TYPE)
		swap_data(type, buffer, length, B_SWAP_ALWAYS);
}


// #pragma mark -


AudioFormatConverter::AudioFormatConverter(AudioReader* source, uint32 format,
		uint32 byteOrder)
	:
	AudioReader(),
	fSource(NULL)
{
	uint32 hostByteOrder
		= (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
	if (source && source->Format().type == B_MEDIA_RAW_AUDIO
		&& source->Format().u.raw_audio.byte_order == hostByteOrder) {
		fFormat = source->Format();
		fFormat.u.raw_audio.format = format;
		fFormat.u.raw_audio.byte_order = byteOrder;
		int32 inSampleSize = source->Format().u.raw_audio.format
			& media_raw_audio_format::B_AUDIO_SIZE_MASK;
		int32 outSampleSize = fFormat.u.raw_audio.format
			& media_raw_audio_format::B_AUDIO_SIZE_MASK;
		if (inSampleSize != outSampleSize) {
			fFormat.u.raw_audio.buffer_size
				= source->Format().u.raw_audio.buffer_size * outSampleSize
				  / inSampleSize;
		}
	} else
		source = NULL;
	fSource = source;
}


AudioFormatConverter::~AudioFormatConverter()
{
}


bigtime_t
AudioFormatConverter::InitialLatency() const
{
	return fSource->InitialLatency();
}

status_t
AudioFormatConverter::Read(void* buffer, int64 pos, int64 frames)
{
	TRACE("AudioFormatConverter::Read(%p, %lld, %lld)\n", buffer, pos, frames);
	status_t error = InitCheck();
	if (error != B_OK) {
		TRACE("AudioFormatConverter::Read() done 1\n");
		return error;
	}
	pos += fOutOffset;

	if (fFormat.u.raw_audio.format == fSource->Format().u.raw_audio.format
		&& fFormat.u.raw_audio.byte_order
		   == fSource->Format().u.raw_audio.byte_order) {
		TRACE("AudioFormatConverter::Read() done 2\n");
		return fSource->Read(buffer, pos, frames);
	}

	int32 inSampleSize = fSource->Format().u.raw_audio.format
		& media_raw_audio_format::B_AUDIO_SIZE_MASK;
	int32 outSampleSize = fFormat.u.raw_audio.format
		& media_raw_audio_format::B_AUDIO_SIZE_MASK;
	int32 channelCount = fFormat.u.raw_audio.channel_count;
	int32 inFrameSize = inSampleSize * channelCount;
	int32 outFrameSize = outSampleSize * channelCount;
	char* reformatBuffer = NULL;
	char* inBuffer = (char*)buffer;

	#ifdef TRACE_AUDIO_CONVERTER
		char formatString[256];
		string_for_format(fSource->Format(), formatString, 256);
		TRACE("  source format: %s\n", formatString);
		TRACE("  in format : format: %lx, sample size: %ld, channels: %ld, "
			"byte order: %lu\n", fSource->Format().u.raw_audio.format,
			inSampleSize, channelCount,
			fSource->Format().u.raw_audio.byte_order);
		TRACE("  out format: format: %lx, sample size: %ld, channels: %ld, "
			"byte order: %lu\n", fFormat.u.raw_audio.format, outSampleSize,
			channelCount, fFormat.u.raw_audio.byte_order);
	#endif // TRACE_AUDIO_CONVERTER

	if (inSampleSize != outSampleSize) {
		reformatBuffer = new char[frames * inFrameSize];
		inBuffer = reformatBuffer;
	}
	error = fSource->Read(inBuffer, pos, frames);
	// convert samples to host endianess
	uint32 hostByteOrder
		= (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
	if (fSource->Format().u.raw_audio.byte_order != hostByteOrder) {
		swap_sample_byte_order(inBuffer, fSource->Format().u.raw_audio.format,
							   frames * inFrameSize);
	}
	// convert the sample type
	switch (fSource->Format().u.raw_audio.format) {
		// float
		case media_raw_audio_format::B_AUDIO_FLOAT:
			switch (fFormat.u.raw_audio.format) {
				case media_raw_audio_format::B_AUDIO_FLOAT:
					break;
				case media_raw_audio_format::B_AUDIO_INT:
					convert(ReadFloat(), WriteInt(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_SHORT:
					convert(ReadFloat(), WriteShort(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_UCHAR:
					convert(ReadFloat(), WriteUChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_CHAR:
					convert(ReadFloat(), WriteChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
			}
			break;
		// int
		case media_raw_audio_format::B_AUDIO_INT:
			switch (fFormat.u.raw_audio.format) {
				case media_raw_audio_format::B_AUDIO_FLOAT:
					convert(ReadInt(), WriteFloat(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_INT:
					break;
				case media_raw_audio_format::B_AUDIO_SHORT:
					convert(ReadInt(), WriteShort(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_UCHAR:
					convert(ReadInt(), WriteUChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_CHAR:
					convert(ReadInt(), WriteChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
			}
			break;
		// short
		case media_raw_audio_format::B_AUDIO_SHORT:
			switch (fFormat.u.raw_audio.format) {
				case media_raw_audio_format::B_AUDIO_FLOAT:
					convert(ReadShort(), WriteFloat(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_INT:
					convert(ReadShort(), WriteInt(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_SHORT:
					break;
				case media_raw_audio_format::B_AUDIO_UCHAR:
					convert(ReadShort(), WriteUChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_CHAR:
					convert(ReadShort(), WriteChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
			}
			break;
		// uchar
		case media_raw_audio_format::B_AUDIO_UCHAR:
			switch (fFormat.u.raw_audio.format) {
				case media_raw_audio_format::B_AUDIO_FLOAT:
					convert(ReadUChar(), WriteFloat(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_INT:
					convert(ReadUChar(), WriteInt(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_SHORT:
					convert(ReadUChar(), WriteShort(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_UCHAR:
					break;
				case media_raw_audio_format::B_AUDIO_CHAR:
					convert(ReadUChar(), WriteChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
			}
			break;
		// char
		case media_raw_audio_format::B_AUDIO_CHAR:
			switch (fFormat.u.raw_audio.format) {
				case media_raw_audio_format::B_AUDIO_FLOAT:
					convert(ReadChar(), WriteFloat(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_INT:
					convert(ReadChar(), WriteInt(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_SHORT:
					convert(ReadChar(), WriteShort(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_UCHAR:
					convert(ReadChar(), WriteUChar(), inBuffer, (char*)buffer,
							frames, inSampleSize, outSampleSize, channelCount);
					break;
				case media_raw_audio_format::B_AUDIO_CHAR:
					break;
			}
			break;
	}
	// convert samples to output endianess
	if (fFormat.u.raw_audio.byte_order != hostByteOrder) {
		swap_sample_byte_order(buffer, fFormat.u.raw_audio.format,
							   frames * outFrameSize);
	}

	delete[] reformatBuffer;
	TRACE("AudioFormatConverter::Read() done\n");
	return B_OK;
}


status_t
AudioFormatConverter::InitCheck() const
{
	status_t error = AudioReader::InitCheck();
	if (error == B_OK && !fSource)
		error = B_NO_INIT;
	if (error == B_OK)
		error = fSource->InitCheck();
	return error;
}


AudioReader*
AudioFormatConverter::Source() const
{
	return fSource;
}