#include "tsop.h"

#include "tsound_t.h"

//TRop::ResampleFilterType Tau_resample_filter = Hamming3;

//---------------------------------------------------------

typedef enum {

	FLT_NONE,

	FLT_TRIANGLE, /* triangle filter */

	FLT_MITCHELL, /* Mitchell-Netravali filter */

	FLT_CUBIC_5,  /* cubic convolution, a = .5 */

	FLT_CUBIC_75, /* cubic convolution, a = .75 */

	FLT_CUBIC_1,  /* cubic convolution, a = 1 */

	FLT_HANN2,	/* Hann window, rad = 2 */

	FLT_HANN3,	/* Hann window, rad = 3 */

	FLT_HAMMING2, /* Hamming window, rad = 2 */

	FLT_HAMMING3, /* Hamming window, rad = 3 */

	FLT_LANCZOS2, /* Lanczos window, rad = 2 */

	FLT_LANCZOS3, /* Lanczos window, rad = 3 */

	FLT_GAUSS,	/* Gaussian convolution */

	FLT_HOW_MANY

} FLT_TYPE;

//---------------------------------------------------------

typedef enum {

	RESORDER_NONE,

	RESORDER_BITS_RATE_CHANS,

	RESORDER_CHANS_RATE_BITS,

	RESORDER_RATE_BITS_CHANS,

	RESORDER_CHANS_BITS_RATE,

	RESORDER_BITS_RATE,

	RESORDER_RATE_BITS,

	RESORDER_CHANS_RATE,

	RESORDER_RATE_CHANS,

	RESORDER_RATE,

	RESORDER_SIGN,

	RESORDER_HOW_MANY

} RESORDER_TYPE;

//---------------------------------------------------------

typedef struct

	{

	int src_offset; /* of weight[0] relative to start of period */

	int n_weights;

	double *weight; /* [n_weights],  -1.0 <= weight <= 1.0 */

} WEIGHTSET;

//---------------------------------------------------------

typedef struct

	{

	int src_period; /* after a period src and dst are in step again */

	int dst_period;

	WEIGHTSET *weightset; /* [dst_period] */

} FILTER;

//---------------------------------------------------------

#define M_PIF ((float)TConsts::pi)

#define SINC0(x, a) (sin((TConsts::pi / (a)) * (x)) / ((TConsts::pi / (a)) * (x)))

#define SINC0F(x, a) (sinf((M_PIF / (a)) * (x)) / ((M_PIF / (a)) * (x)))

#define SINC(x, a) ((x) == 0.0 ? 1.0 : SINC0(x, a))

#define SINCF(x, a) ((x) == 0.0F ? 1.0F : SINC0F(x, a))

#define FULL_INT_MUL_DIV(X, Y, Z) ((int)(((double)(X) * (Y) + ((Z)-1)) / (Z)))

//prototipi

void convert(TSoundTrackP &dst, const TSoundTrackP &src);

namespace

{

//---------------------------------------------------------

void simplifyRatio(int *p_a, int *p_b)

{

	int a = *p_a, b = *p_b;

	while (a != b)

		if (a > b)

			a -= b;

		else

			b -= a;

	if (a != 1) {

		*p_a /= a;

		*p_b /= a;

	}

}

//---------------------------------------------------------

int getFilterRadius(FLT_TYPE flt_type)

{

	int result = 0;

	switch (flt_type) {

	case FLT_TRIANGLE:

		result = 1;

		CASE FLT_MITCHELL : result = 2;

		CASE FLT_CUBIC_5 : result = 2;

		CASE FLT_CUBIC_75 : result = 2;

		CASE FLT_CUBIC_1 : result = 2;

		CASE FLT_HANN2 : result = 2;

		CASE FLT_HANN3 : result = 3;

		CASE FLT_HAMMING2 : result = 2;

		CASE FLT_HAMMING3 : result = 3;

		CASE FLT_LANCZOS2 : result = 2;

		CASE FLT_LANCZOS3 : result = 3;

		CASE FLT_GAUSS : result = 2;

	DEFAULT:

		assert(!"bad filter type");

		break;

	}

	return result;

}

//---------------------------------------------------------

double filterValue(FLT_TYPE flt_type, double x)

{

	if (!x)

		return 1.0;

	double result;

	switch (flt_type) {

	case FLT_TRIANGLE:

		if (x < -1.0)

			result = 0.0;

		else if (x < 0.0)

			result = 1.0 + x;

		else if (x < 1.0)

			result = 1.0 - x;

		else

			result = 0.0;

		CASE FLT_MITCHELL:

		{

			static double p0, p2, p3, q0, q1, q2, q3;

			if (!p0) {

				const double b = 1.0 / 3.0;

				const double c = 1.0 / 3.0;

				p0 = (6.0 - 2.0 * b) / 6.0;

				p2 = (-18.0 + 12.0 * b + 6.0 * c) / 6.0;

				p3 = (12.0 - 9.0 * b - 6.0 * c) / 6.0;

				q0 = (8.0 * b + 24.0 * c) / 6.0;

				q1 = (-12.0 * b - 48.0 * c) / 6.0;

				q2 = (6.0 * b + 30.0 * c) / 6.0;

				q3 = (-b - 6.0 * c) / 6.0;

			}

			if (x < -2.0)

				result = 0.0;

			else if (x < -1.0)

				result = (q0 - x * (q1 - x * (q2 - x * q3)));

			else if (x < 0.0)

				result = (p0 + x * x * (p2 - x * p3));

			else if (x < 1.0)

				result = (p0 + x * x * (p2 + x * p3));

			else if (x < 2.0)

				result = (q0 + x * (q1 + x * (q2 + x * q3)));

		}

		CASE FLT_CUBIC_5 : if (x < 0.0) x = -x;

		else if (x < 1.0) result = 2.5 * x * x * x - 3.5 * x * x + 1;

		else if (x < 2.0) result = 0.5 * x * x * x - 2.5 * x * x + 4 * x - 2;

		CASE FLT_CUBIC_75 : if (x < 0.0) x = -x;

		else if (x < 1.0) result = 2.75 * x * x * x - 3.75 * x * x + 1;

		else if (x < 2.0) result = 0.75 * x * x * x - 3.75 * x * x + 6 * x - 3;

		CASE FLT_CUBIC_1 : if (x < 0.0) x = -x;

		else if (x < 1.0) result = 3 * x * x * x - 4 * x * x + 1;

		else if (x < 2.0) result = x * x * x - 5 * x * x + 8 * x - 4;

		CASE FLT_HANN2 : if (x <= -2.0) result = 0.0;

		else if (x < 2.0) result = SINC0(x, 1) * (0.5 + 0.5 * cos((TConsts::pi_2)*x));

		CASE FLT_HANN3 : if (x <= -3.0) result = 0.0;

		else if (x < 3.0) result = SINC0(x, 1) * (0.5 + 0.5 * cos((TConsts::pi / 3) * x));

		CASE FLT_HAMMING2 : if (x <= -2.0) result = 0.0;

		else if (x < 2.0) result = SINC0(x, 1) * (0.54 + 0.46 * cos((TConsts::pi_2)*x));

		CASE FLT_HAMMING3 : if (x <= -3.0) result = 0.0;

		else if (x < 3.0) result = SINC0(x, 1) * (0.54 + 0.46 * cos((TConsts::pi / 3) * x));

		CASE FLT_LANCZOS2 : if (x <= -2.0) result = 0.0;

		else if (x < 2.0) result = SINC0(x, 1) * SINC0(x, 2);

		CASE FLT_LANCZOS3 : if (x <= -3.0) result = 0.0;

		else if (x < 3.0) result = SINC0(x, 1) * SINC0(x, 3);

		CASE FLT_GAUSS : if (x <= -2.0) result = 0.0;

		else if (x < 2.0) result = exp((-TConsts::pi) * x * x);

	/* exp(-M_PI*2*2)~=3.5*10^-6 */

	DEFAULT:

		assert(!"bad filter type");

	}

	return result;

}

//---------------------------------------------------------

} //namespace

//==============================================================================

template <class class="" t1,="" t2=""></class>

void convertSamplesT(TSoundTrackT<t1> &dst, const TSoundTrackT<t2> &src)</t2></t1>

{

	const T2 *srcSample = src.samples();

	T1 *dstSample = dst.samples();

	const T2 *srcEndSample = srcSample + tmin(src.getSampleCount(), dst.getSampleCount());

	while (srcSample < srcEndSample) {

		*dstSample = T1::from(*srcSample);

		++dstSample;

		++srcSample;

	}

}

//==============================================================================

template <class t=""></class>

T *resampleT(T &src, TINT32 sampleRate, FLT_TYPE flt_type)

{

	typedef typename T::SampleType SampleType;

	typedef typename T::SampleType::ChannelValueType ChannelValueType;

	T *dst = new TSoundTrackT<sampletype>(</sampletype>

		sampleRate,

		src.getChannelCount(),

		(TINT32)(src.getSampleCount() * (sampleRate / (double)src.getSampleRate())));

	double src_rad, f, src_f0, src_to_f;

	double weight, weightsum;

	int iw, is, s0, ip, first, last;

	FILTER filter;

	filter.src_period = (int)src.getSampleRate();

	filter.dst_period = (int)dst->getSampleRate();

	simplifyRatio(&filter.src_period, &filter.dst_period);

	filter.weightset = new WEIGHTSET[filter.dst_period];

	if (!filter.weightset)

		return 0;

	int flt_rad = getFilterRadius(flt_type);

	double dstRate = (double)dst->getSampleRate();

	double srcRate = (double)src.getSampleRate();

	double dst_to_src = srcRate / dstRate;

	if (srcRate > dstRate) {

		src_rad = flt_rad * dst_to_src;

		src_to_f = dstRate / srcRate;

	} else {

		src_rad = flt_rad;

		src_to_f = 1.0;

	}

	for (ip = 0; ip < filter.dst_period; ip++) {

		src_f0 = ip * dst_to_src;

		if (ip == 0 && srcRate < dstRate)

			first = last = 0;

		else {

			first = intGT(src_f0 - src_rad);

			last = intLT(src_f0 + src_rad);

		}

		filter.weightset[ip].src_offset = first;

		filter.weightset[ip].n_weights = last - first + 1;

		filter.weightset[ip].weight = new double[filter.weightset[ip].n_weights];

		if (!filter.weightset[ip].weight)

			return 0;

		weightsum = 0.0;

		for (is = first; is <= last; is++) {

			f = (is - src_f0) * src_to_f;

			weight = filterValue(flt_type, f);

			filter.weightset[ip].weight[is - first] = weight;

			weightsum += weight;

		}

		assert(weightsum);

		for (is = first; is <= last; is++)

			filter.weightset[ip].weight[is - first] /= weightsum;

	}

	ip = 0;

	s0 = 0;

	for (TINT32 id = 0; id < dst->getSampleCount(); id++) {

		SampleType dstSample;

		SampleType srcSample;

		is = s0 + filter.weightset[ip].src_offset;

		int iwFirst, iwLast;

		if (is > 0) {

			iwFirst = 0;

			iwLast = tmin<int>(filter.weightset[ip].n_weights, src.getSampleCount() - is);</int>

		} else {

			iwFirst = -is;

			is = 0;

			iwLast = tmin<int>(filter.weightset[ip].n_weights, src.getSampleCount());</int>

		}

		double dstChannel[2];

		dstChannel[0] = 0;

		dstChannel[1] = 0;

		dstSample = SampleType();

		for (iw = iwFirst; iw < iwLast; iw++, is++) {

			weight = filter.weightset[ip].weight[iw];

			srcSample = *(src.samples() + is);

			/*

      T::SampleType tmp = srcSample*weight;

      dstSample += tmp;

      */

			for (int i = 0; i < src.getChannelCount(); i++)

				dstChannel[i] += (double)(srcSample.getValue(i) * weight);

			//assert(dstSample.getValue(0) == dstChannel[0]);

		}

		for (int i = 0; i < src.getChannelCount(); i++)

			dstSample.setValue(i, (ChannelValueType)(tround(dstChannel[i])));

		*(dst->samples() + id) = dstSample;

		ip++;

		if (ip == filter.dst_period) {

			ip = 0;

			s0 += filter.src_period;

		}

	}

	for (ip = 0; ip < filter.dst_period; ip++)

		delete[] filter.weightset[ip].weight;

	delete[] filter.weightset;

	return dst;

}

//=============================================================================

class TSoundTrackResample : public TSoundTransform

{

	TINT32 m_sampleRate;

	FLT_TYPE m_filterType;

public:

	TSoundTrackResample(TINT32 sampleRate, FLT_TYPE filterType)

		: TSoundTransform(), m_sampleRate(sampleRate), m_filterType(filterType)

	{

	}

	~TSoundTrackResample(){};

	TSoundTrackP compute(const TSoundTrackMono8Signed &src)

	{

		TSoundTrackMono8Signed *dst = resampleT(

			const_cast<tsoundtrackmono8signed &="">(src),</tsoundtrackmono8signed>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

	TSoundTrackP compute(const TSoundTrackMono8Unsigned &src)

	{

		TSoundTrackMono8Unsigned *dst = resampleT(

			const_cast<tsoundtrackmono8unsigned &="">(src),</tsoundtrackmono8unsigned>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

	TSoundTrackP compute(const TSoundTrackStereo8Signed &src)

	{

		TSoundTrackStereo8Signed *dst = resampleT(

			const_cast<tsoundtrackstereo8signed &="">(src),</tsoundtrackstereo8signed>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

	TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src)

	{

		TSoundTrackStereo8Unsigned *dst = resampleT(

			const_cast<tsoundtrackstereo8unsigned &="">(src),</tsoundtrackstereo8unsigned>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

	TSoundTrackP compute(const TSoundTrackMono16 &src)

	{

		TSoundTrackMono16 *dst = resampleT(

			const_cast<tsoundtrackmono16 &="">(src),</tsoundtrackmono16>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

	TSoundTrackP compute(const TSoundTrackStereo16 &src)

	{

		TSoundTrackStereo16 *dst = resampleT(

			const_cast<tsoundtrackstereo16 &="">(src),</tsoundtrackstereo16>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

	TSoundTrackP compute(const TSoundTrackMono24 &src)

	{

		TSoundTrackMono24 *dst = resampleT(

			const_cast<tsoundtrackmono24 &="">(src),</tsoundtrackmono24>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

	TSoundTrackP compute(const TSoundTrackStereo24 &src)

	{

		TSoundTrackStereo24 *dst = resampleT(

			const_cast<tsoundtrackstereo24 &="">(src),</tsoundtrackstereo24>

			m_sampleRate, m_filterType);

		return TSoundTrackP(dst);

	}

};

//==============================================================================

TSoundTrackP TSop::resample(TSoundTrackP src, TINT32 sampleRate)

{

	TSoundTrackResample *resample = new TSoundTrackResample(sampleRate, FLT_HAMMING3);

	TSoundTrackP dst = src->apply(resample);

	delete resample;

	return dst;

}

//==============================================================================

template <class src=""></class>

TSoundTrackP doConvertWithoutResamplingT(

	SRC *src, const TSoundTrackFormat &dstFormat)

{

	TSoundTrackP dst = TSoundTrack::create(dstFormat, src->getSampleCount());

	if (!dst)

		return 0;

	TSoundTrackMono8Unsigned *dstM8U =

		dynamic_cast<tsoundtrackmono8unsigned *="">(dst.getPointer());</tsoundtrackmono8unsigned>

	if (dstM8U) {

		convertSamplesT(*dstM8U, *src);

		return dstM8U;

	}

	TSoundTrackMono8Signed *dstM8S =

		dynamic_cast<tsoundtrackmono8signed *="">(dst.getPointer());</tsoundtrackmono8signed>

	if (dstM8S) {

		convertSamplesT(*dstM8S, *src);

		return dstM8S;

	}

	TSoundTrackStereo8Signed *dstS8S =

		dynamic_cast<tsoundtrackstereo8signed *="">(dst.getPointer());</tsoundtrackstereo8signed>

	if (dstS8S) {

		convertSamplesT(*dstS8S, *src);

		return dstS8S;

	}

	TSoundTrackStereo8Unsigned *dstS8U =

		dynamic_cast<tsoundtrackstereo8unsigned *="">(dst.getPointer());</tsoundtrackstereo8unsigned>

	if (dstS8U) {

		convertSamplesT(*dstS8U, *src);

		return dstS8U;

	}

	TSoundTrackMono16 *dstM16 =

		dynamic_cast<tsoundtrackmono16 *="">(dst.getPointer());</tsoundtrackmono16>

	if (dstM16) {

		convertSamplesT(*dstM16, *src);

		return dstM16;

	}

	TSoundTrackStereo16 *dstS16 =

		dynamic_cast<tsoundtrackstereo16 *="">(dst.getPointer());</tsoundtrackstereo16>

	if (dstS16) {

		convertSamplesT(*dstS16, *src);

		return dstS16;

	}

	TSoundTrackMono24 *dstM24 =

		dynamic_cast<tsoundtrackmono24 *="">(dst.getPointer());</tsoundtrackmono24>

	if (dstM24) {

		convertSamplesT(*dstM24, *src);

		return dstM24;

	}

	TSoundTrackStereo24 *dstS24 =

		dynamic_cast<tsoundtrackstereo24 *="">(dst.getPointer());</tsoundtrackstereo24>

	if (dstS24) {

		convertSamplesT(*dstS24, *src);

		return dstS24;

	}

	return 0;

}

//------------------------------------------------------------------------------

class TSoundTrackConverterWithoutResampling : public TSoundTransform

{

	TSoundTrackFormat m_format;

public:

	TSoundTrackConverterWithoutResampling(const TSoundTrackFormat &format)

		: m_format(format) {}

	~TSoundTrackConverterWithoutResampling(){};

	TSoundTrackP compute(const TSoundTrackMono8Signed &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

	TSoundTrackP compute(const TSoundTrackMono8Unsigned &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

	TSoundTrackP compute(const TSoundTrackStereo8Signed &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

	TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

	TSoundTrackP compute(const TSoundTrackMono16 &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

	TSoundTrackP compute(const TSoundTrackStereo16 &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

	TSoundTrackP compute(const TSoundTrackMono24 &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

	TSoundTrackP compute(const TSoundTrackStereo24 &src)

	{

		return doConvertWithoutResamplingT(&src, m_format);

	}

};

//-----------------------------------------------------------------------------

namespace

{

void convertWithoutResampling(TSoundTrackP &dst, const TSoundTrackP &src)

{

	TSoundTrackConverterWithoutResampling *converter;

	converter = new TSoundTrackConverterWithoutResampling(dst->getFormat());

	dst = src->apply(converter);

	delete converter;

}

} // namespace

//==============================================================================

TSoundTrackP TSop::convert(

	const TSoundTrackP &src,

	const TSoundTrackFormat &dstFormat)

{

	TINT32 dstSampleCount =

		(TINT32)(src->getSampleCount() * (dstFormat.m_sampleRate / (double)src->getSampleRate()));

	TSoundTrackP dst = TSoundTrack::create(dstFormat, dstSampleCount);

	TSop::convert(dst, src);

	return dst;

}

//------------------------------------------------------------------------------

void TSop::convert(TSoundTrackP &dst, const TSoundTrackP &src)

{

	int src_reslen, dst_reslen;

	int src_bits, dst_bits;

	int src_chans, dst_chans;

	TSoundTrackP tmp, tmq;

	RESORDER_TYPE order;

	assert(src->getSampleCount() >= 0 && dst->getSampleCount() >= 0);

	if (!dst->getSampleCount())

		return;

	if (!src->getSampleCount()) {

		dst->blank(0L, (TINT32)(dst->getSampleCount() - 1));

		return;

	}

	if (src->getSampleRate() == dst->getSampleRate()) {

		src_reslen = dst->getSampleCount();

		notMoreThan((int)src->getSampleCount(), src_reslen);

		dst_reslen = src_reslen;

		convertWithoutResampling(dst, src);

	} else {

		src_reslen = FULL_INT_MUL_DIV(

			dst->getSampleCount(),

			src->getSampleRate(),

			dst->getSampleRate());

		if (src_reslen > src->getSampleCount()) {

			src_reslen = src->getSampleCount();

			dst_reslen = FULL_INT_MUL_DIV(

				src_reslen, dst->getSampleRate(), src->getSampleRate());

		} else

			dst_reslen = dst->getSampleCount();

		src_chans = src->getChannelCount();

		dst_chans = dst->getChannelCount();

		src_bits = src->getBitPerSample();

		dst_bits = dst->getBitPerSample();

		if (src_chans == dst_chans && src_bits == dst_bits)

			if (src->isSampleSigned() == dst->isSampleSigned())

				order = RESORDER_RATE;

			else

				order = RESORDER_SIGN;

		else if (src_chans < dst_chans) {

			if (src_bits < dst_bits)

				order = RESORDER_BITS_RATE_CHANS;

			else

				order = RESORDER_RATE_BITS_CHANS;

		} else if (src_chans > dst_chans) {

			if (src_bits > dst_bits)

				order = RESORDER_CHANS_RATE_BITS;

			else

				order = RESORDER_CHANS_BITS_RATE;

		} else {

			if (src_bits > dst_bits)

				order = RESORDER_RATE_BITS;

			else

				order = RESORDER_BITS_RATE;

		}

		switch (order) {

		case RESORDER_CHANS_RATE_BITS:

		case RESORDER_BITS_RATE_CHANS:

			int chans, bitPerSample;

			if (src->getChannelCount() <= dst->getChannelCount())

				chans = src->getChannelCount();

			else

				chans = dst->getChannelCount();

			if (src->getBitPerSample() >= dst->getBitPerSample())

				bitPerSample = src->getBitPerSample();

			else

				bitPerSample = dst->getBitPerSample();

			tmp = TSoundTrack::create(

				(int)src->getSampleRate(),

				bitPerSample,

				chans,

				src_reslen * src->getSampleSize());

			convertWithoutResampling(tmp, src);

			tmq = TSop::resample(tmp, (TINT32)dst->getSampleRate());

			convertWithoutResampling(dst, tmq);

			break;

		case RESORDER_RATE_BITS_CHANS:

		case RESORDER_RATE_BITS:

		case RESORDER_RATE_CHANS:

			tmp = TSop::resample(src, (TINT32)dst->getSampleRate());

			convertWithoutResampling(dst, tmp);

			break;

		case RESORDER_CHANS_BITS_RATE:

		case RESORDER_BITS_RATE:

		case RESORDER_CHANS_RATE:

		case RESORDER_SIGN:

			tmp = TSoundTrack::create(

				(int)src->getSampleRate(),

				dst->getBitPerSample(),

				dst->getChannelCount(),

				src_reslen * dst->getSampleSize(),

				dst->isSampleSigned());

			convertWithoutResampling(tmp, src);

			dst = TSop::resample(tmp, (TINT32)dst->getSampleRate());

			break;

		case RESORDER_RATE:

			dst = TSop::resample(src, (TINT32)dst->getSampleRate());

			break;

		default:

			assert(false);

			break;

		}

	}

	if (dst_reslen < dst->getSampleCount())

		dst->blank((TINT32)dst_reslen, (TINT32)(dst->getSampleCount() - 1));

}

//==============================================================================

template <class t=""></class>

TSoundTrackP doReverb(

	TSoundTrackT<t> *src,</t>

	double delayTime,

	double decayFactor,

	double extendTime)

{

	TINT32 dstSampleCount = src->getSampleCount() + (TINT32)(src->getSampleRate() * extendTime);

	TSoundTrackT<t> *dst = new TSoundTrackT<t>(</t></t>

		src->getSampleRate(),

		src->getChannelCount(),

		dstSampleCount);

	TINT32 sampleRate = (TINT32)src->getSampleRate();

	TINT32 k = (TINT32)(sampleRate * delayTime);

	T *srcSample = src->samples();

	T *dstSample = dst->samples();

	T *endDstSample = dst->samples() + k;

	while (dstSample < endDstSample)

		*dstSample++ = *srcSample++;

	// la formula del reverb e'

	// out(i) = in(i) + decayFactor * out(i - k)

	//  int channelCount = src->getChannelCount();

	endDstSample = dst->samples() + tmin(dstSampleCount, (TINT32)src->getSampleCount());

	while (dstSample < endDstSample) {

		//*dstSample = *srcSample + *(dstSample - k)*decayFactor;

		*dstSample = T::mix(*srcSample, 1, *(dstSample - k), decayFactor);

		++dstSample;

		++srcSample;

	}

	endDstSample = dst->samples() + dstSampleCount;

	while (dstSample < endDstSample) {

		//*dstSample = *(dstSample - k)*decayFactor;

		*dstSample = T::mix(T(), 0, *(dstSample - k), decayFactor);

		++dstSample;

	}

	return TSoundTrackP(dst);

}

//==============================================================================

class TSoundReverb : public TSoundTransform

{

	double m_delayTime;

	double m_decayFactor;

	double m_extendTime;

public:

	TSoundReverb(

		double delayTime,

		double decayFactor,

		double extendTime)

		: m_delayTime(delayTime), m_decayFactor(decayFactor), m_extendTime(extendTime)

	{

	}

	~TSoundReverb() {}

	virtual TSoundTrackP compute(const TSoundTrackMono8Signed &src)

	{

		return doReverb(

			const_cast<tsoundtrackmono8signed *="">(&src),</tsoundtrackmono8signed>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

	virtual TSoundTrackP compute(const TSoundTrackMono8Unsigned &src)

	{

		return doReverb(

			const_cast<tsoundtrackmono8unsigned *="">(&src),</tsoundtrackmono8unsigned>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

	virtual TSoundTrackP compute(const TSoundTrackStereo8Signed &src)

	{

		return doReverb(

			const_cast<tsoundtrackstereo8signed *="">(&src),</tsoundtrackstereo8signed>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

	virtual TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src)

	{

		return doReverb(

			const_cast<tsoundtrackstereo8unsigned *="">(&src),</tsoundtrackstereo8unsigned>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

	virtual TSoundTrackP compute(const TSoundTrackMono16 &src)

	{

		return doReverb(

			const_cast<tsoundtrackmono16 *="">(&src),</tsoundtrackmono16>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

	virtual TSoundTrackP compute(const TSoundTrackStereo16 &src)

	{

		return doReverb(

			const_cast<tsoundtrackstereo16 *="">(&src),</tsoundtrackstereo16>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

	virtual TSoundTrackP compute(const TSoundTrackMono24 &src)

	{

		return doReverb(

			const_cast<tsoundtrackmono24 *="">(&src),</tsoundtrackmono24>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

	virtual TSoundTrackP compute(const TSoundTrackStereo24 &src)

	{

		return doReverb(

			const_cast<tsoundtrackstereo24 *="">(&src),</tsoundtrackstereo24>

			m_delayTime,

			m_decayFactor,

			m_extendTime);

	}

};

//==============================================================================

TSoundTrackP TSop::reverb(

	TSoundTrackP src,

	double delayTime,

	double decayFactor,

	double extendTime)

{

	TSoundReverb *reverb = new TSoundReverb(delayTime, decayFactor, extendTime);

	assert(reverb);