/*
 * Copyright 2010-2014 Haiku, inc.
 * Distributed under the terms of the MIT Licence.
 *
 * Author: Adrien Destugues <pulkomandy@pulkomandy.tk>
 */


#include "Interpolate.h"

#include <cmath>

#include <MediaDefs.h>

#include "MixerDebug.h"


/*! Resampling class doing linear interpolation.
*/


template<typename inType, typename outType, int gnum, int gden,
	int inMiddle, int outMiddle, int32 min, int32 max> static void
kernel(Resampler* object, const void *_src, int32 srcSampleOffset,
	int32 srcSampleCount, void *_dest, int32 destSampleOffset,
	int32 destSampleCount, float _gain)
{
	const char * src = (const char *)_src;
	char * dest = (char *)_dest;
	int32 count = destSampleCount;
	float gain = _gain * gnum / gden;

	if (srcSampleCount == destSampleCount) {
		// optimized case for no resampling
		while (count--) {
			float tmp = ((*(const inType*)src) - inMiddle) * gain + outMiddle;
			if (tmp <= min)
				*(outType *)dest = min;
			else if (tmp >= max)
				*(outType *)dest = max;
			else
				*(outType *)dest = (outType)tmp;
			src += srcSampleOffset;
			dest += destSampleOffset;
		}
		return;
	}

	float delta = float(srcSampleCount) / float(destSampleCount);
	float current = 0.0f;
	float oldSample = ((Interpolate*)object)->fOldSample;

	#define SRC *(const inType*)(src)

	while (count--) {
		float tmp = (gain * (oldSample + (SRC - oldSample) * current - inMiddle)
			+ outMiddle);
		if (tmp <= min)
			*(outType *)dest = min;
		else if (tmp >= max)
			*(outType *)dest = max;
		else
			*(outType *)dest = (outType)tmp;

		dest += destSampleOffset;
		current += delta;
		if (current >= 1.0f) {
			double ipart;
			current = modf(current, &ipart);
			oldSample = SRC;
			src += srcSampleOffset * (int)ipart;
		}
	}

	((Interpolate*)object)->fOldSample = oldSample;
}


Interpolate::Interpolate(uint32 src_format, uint32 dst_format)
	:
	Resampler(),
	fOldSample(0)
{
	if (src_format == media_raw_audio_format::B_AUDIO_UCHAR)
		fOldSample = 128;

	if (dst_format == media_raw_audio_format::B_AUDIO_FLOAT) {
		switch (src_format) {
			case media_raw_audio_format::B_AUDIO_FLOAT:
				fFunc = &kernel<float, float, 1, 1, 0, 0, -1, 1>;
				return;
			case media_raw_audio_format::B_AUDIO_INT:
				fFunc = &kernel<int32, float, 1, INT32_MAX, 0, 0, -1, 1>;
				return;
			case media_raw_audio_format::B_AUDIO_SHORT:
				fFunc = &kernel<int16, float, 1, INT16_MAX, 0, 0, -1, 1>;
				return;
			case media_raw_audio_format::B_AUDIO_CHAR:
				fFunc = &kernel<int8, float, 1, INT8_MAX, 0, 0, -1, 1>;
				return;
			case media_raw_audio_format::B_AUDIO_UCHAR:
				fFunc = &kernel<uint8, float, 2, UINT8_MAX, 128, 0, -1, 1>;
				return;
			default:
				ERROR("Resampler::Resampler: unknown source format 0x%x\n",
					src_format);
				return;
		}
	}

	if (src_format == media_raw_audio_format::B_AUDIO_FLOAT) {
		switch (dst_format) {
			// float=>float already handled above
			case media_raw_audio_format::B_AUDIO_INT:
				fFunc = &kernel<float, int32, INT32_MAX, 1, 0, 0,
					INT32_MIN, INT32_MAX>;
				return;
			case media_raw_audio_format::B_AUDIO_SHORT:
				fFunc = &kernel<float, int16, INT16_MAX, 1, 0, 0,
					INT16_MIN, INT16_MAX>;
				return;
			case media_raw_audio_format::B_AUDIO_CHAR:
				fFunc = &kernel<float, int8, INT8_MAX, 1, 0, 0,
					INT8_MIN, INT8_MAX>;
				return;
			case media_raw_audio_format::B_AUDIO_UCHAR:
				fFunc = &kernel<float, uint8, UINT8_MAX, 2, 0, 128,
					0, UINT8_MAX>;
				return;
			default:
				ERROR("Resampler::Resampler: unknown destination format 0x%x\n",
					dst_format);
				return;
		}
	}

	ERROR("Resampler::Resampler: source or destination format must be "
		"B_AUDIO_FLOAT\n");
}