/*
* Paula.cpp
* ---------
* Purpose: Emulating the Amiga's sound chip, Paula, by implementing resampling using band-limited steps (BLEPs)
* Notes  : The BLEP table generator code is a translation of Antti S. Lankila's original Python code.
* Authors: OpenMPT Devs
*          Antti S. Lankila
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/

#include "stdafx.h"
#include "Paula.h"
#include "TinyFFT.h"
#include "Tables.h"
#include "mpt/base/numbers.hpp"

#include <complex>
#include <numeric>

OPENMPT_NAMESPACE_BEGIN

namespace Paula
{

namespace
{

MPT_NOINLINE std::vector<double> KaiserFIR(int numTaps, double cutoff, double beta)
{
	const double izeroBeta = Izero(beta);
	const double kPi = 4.0 * std::atan(1.0) * cutoff;
	const double xDiv = 1.0 / ((numTaps / 2) * (numTaps / 2));
	const int numTapsDiv2 = numTaps / 2;
	std::vector<double> result(numTaps);
	for(int i = 0; i < numTaps; i++)
	{
		double fsinc;
		if(i == numTapsDiv2)
		{
			fsinc = 1.0;
		} else
		{
			const double x = i - numTapsDiv2;
			const double xPi = x * kPi;
			//      -   sinc    -   -                   Kaiser window                   -   -sinc-
			fsinc = std::sin(xPi) * Izero(beta * std::sqrt(1 - x * x * xDiv)) / (izeroBeta * xPi);
		}

		result[i] = fsinc * cutoff;
	}
	return result;
}


MPT_NOINLINE void FIR_MinPhase(std::vector<double> &table, const TinyFFT &fft)
{
	std::vector<std::complex<double>> cepstrum(fft.Size());
	MPT_ASSERT(cepstrum.size() >= table.size());
	for(size_t i = 0; i < table.size(); i++)
		cepstrum[i] = table[i];
	// Compute the real cepstrum: fft -> abs + ln -> ifft -> real
	fft.FFT(cepstrum);
	for(auto &v : cepstrum)
		v = std::log(std::abs(v));
	fft.IFFT(cepstrum);
	fft.Normalize(cepstrum);

	// Window the cepstrum in such a way that anticausal components become rejected
	for(size_t i = 1; i < cepstrum.size() / 2; i++)
	{
		cepstrum[i] *= 2;
		cepstrum[i + cepstrum.size() / 2] *= 0;
	}

	// Now cancel the previous steps: fft -> exp -> ifft -> real
	fft.FFT(cepstrum);
	for(auto &v : cepstrum)
		v = std::exp(v);
	fft.IFFT(cepstrum);
	fft.Normalize(cepstrum);
	for(size_t i = 0; i < table.size(); i++)
		table[i] = cepstrum[i].real();
}


class BiquadFilter
{
	double b0, b1, b2, a1, a2, x1 = 0.0, x2 = 0.0, y1 = 0.0, y2 = 0.0;

	double Filter(double x0)
	{
		double y0 = b0 * x0 + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
		x2 = x1;
		x1 = x0;
		y2 = y1;
		y1 = y0;
		return y0;
	}

public:
	BiquadFilter(double b0_, double b1_, double b2_, double a1_, double a2_)
	    : b0(b0_), b1(b1_), b2(b2_), a1(a1_), a2(a2_)
	{ }

	std::vector<double> Run(std::vector<double> table)
	{
		x1 = 0.0;
		x2 = 0.0;
		y1 = 0.0;
		y2 = 0.0;

		// Initialize filter to stable state
		for(int i = 0; i < 10000; i++)
			Filter(table[0]);
		// Now run the filter
		for(auto &v : table)
			v = Filter(v);

		return table;
	}
};


// Observe: a and b are reversed here. To be absolutely clear:
// a is the nominator and b is the denominator. :-/
BiquadFilter ZTransform(double a0, double a1, double a2, double b0, double b1, double b2, double fc, double fs)
{
	// Prewarp s - domain coefficients
	const double wp = 2.0 * fs * std::tan(mpt::numbers::pi * fc / fs);
	a2 /= wp * wp;
	a1 /= wp;
	b2 /= wp * wp;
	b1 /= wp;

	// Compute bilinear transform and return it
	const double bd = 4 * b2 * fs * fs + 2 * b1 * fs + b0;
	return BiquadFilter(
	    (4 * a2 * fs * fs + 2 * a1 * fs + a0) / bd,
	    (2 * a0 - 8 * a2 * fs * fs) / bd,
	    (4 * a2 * fs * fs - 2 * a1 * fs + a0) / bd,
	    (2 * b0 - 8 * b2 * fs * fs) / bd,
	    (4 * b2 * fs * fs - 2 * b1 * fs + b0) / bd);
}


BiquadFilter MakeRCLowpass(double sampleRate, double freq)
{
	const double omega = (2.0 * mpt::numbers::pi) * freq / sampleRate;
	const double term = 1 + 1 / omega;
	return BiquadFilter(1 / term, 0.0, 0.0, -1.0 + 1.0 / term, 0.0);
}


BiquadFilter MakeButterworth(double fs, double fc, double res_dB = 0)
{
	// 2nd-order Butterworth s-domain coefficients are:
	//
	// b0 = 1.0  b1 = 0        b2 = 0
	// a0 = 1    a1 = sqrt(2)  a2 = 1
	//
	// by tweaking the a1 parameter, some resonance can be produced.

	const double res = std::pow(10.0, (-res_dB / 10.0 / 2.0));
	return ZTransform(1, 0, 0, 1, std::sqrt(2) * res, 1, fc, fs);
}


MPT_NOINLINE void Integrate(std::vector<double> &table)
{
	const double total = std::accumulate(table.begin(), table.end(), 0.0);
	double startVal = -total;

	for(auto &v : table)
	{
		startVal += v;
		v = startVal;
	}
}


MPT_NOINLINE void Quantize(const std::vector<double> &in, Paula::BlepArray &quantized)
{
	MPT_ASSERT(in.size() == Paula::BLEP_SIZE);
	constexpr int fact = 1 << Paula::BLEP_SCALE;
	const double cv = fact / (in.back() - in.front());

	for(int i = 0; i < Paula::BLEP_SIZE; i++)
	{
		double val = in[i] * cv;
#ifdef MPT_INTMIXER
		val = mpt::round(val);
#endif
		quantized[i] = static_cast<mixsample_t>(-val);
	}
}

}  // namespace

void BlepTables::InitTables()
{
	constexpr double sampleRate = Paula::PAULA_HZ;

	// Because Amiga only has 84 dB SNR, the noise floor is low enough with -90 dB.
	// A500 model uses slightly lower-quality kaiser window to obtain slightly
	// steeper stopband attenuation. The fixed filters attenuates the sidelobes by
	// 12 dB, compensating for the worse performance of the kaiser window.

	// 21 kHz stopband is not fully attenuated by 22 kHz. If the sampling frequency
	// is 44.1 kHz, all frequencies above 22 kHz will alias over 20 kHz, thus inaudible.
	// The output should be aliasingless for 48 kHz sampling frequency.
	auto unfilteredA500 = KaiserFIR(Paula::BLEP_SIZE, 21000.0 / sampleRate * 2.0, 8.0);
	auto unfilteredA1200 = KaiserFIR(Paula::BLEP_SIZE, 21000.0 / sampleRate * 2.0, 9.0);
	// Move filtering effects to start to allow IIRs more time to settle
	constexpr size_t padSize = 8;
	constexpr int fftSize = static_cast<int>(mpt::bit_width(size_t(Paula::BLEP_SIZE)) + mpt::bit_width(padSize) - 2);
	const TinyFFT fft(fftSize);
	FIR_MinPhase(unfilteredA500, fft);
	FIR_MinPhase(unfilteredA1200, fft);

	// Make digital models for the filters on Amiga 500 and 1200.
	auto filterFixed5kHz = MakeRCLowpass(sampleRate, 4900.0);
	// The leakage filter seems to reduce treble in both models a bit
	// The A500 filter seems to be well modelled only with a 4.9 kHz
	// filter although the component values would suggest 5 kHz filter.
	auto filterLeakage = MakeRCLowpass(sampleRate, 32000.0);
	auto filterLED = MakeButterworth(sampleRate, 3275.0, -0.70);

	// Apply fixed filter to A500
	auto amiga500Off = filterFixed5kHz.Run(unfilteredA500);
	// Produce the filtered outputs
	auto amiga1200Off = filterLeakage.Run(unfilteredA1200);

	// Produce LED filters
	auto amiga500On = filterLED.Run(amiga500Off);
	auto amiga1200On = filterLED.Run(amiga1200Off);

	// Integrate to produce blep
	Integrate(amiga500Off);
	Integrate(amiga500On);
	Integrate(amiga1200Off);
	Integrate(amiga1200On);
	Integrate(unfilteredA1200);

	// Quantize and scale
	Quantize(amiga500Off, WinSincIntegral[A500Off]);
	Quantize(amiga500On, WinSincIntegral[A500On]);
	Quantize(amiga1200Off, WinSincIntegral[A1200Off]);
	Quantize(amiga1200On, WinSincIntegral[A1200On]);
	Quantize(unfilteredA1200, WinSincIntegral[Unfiltered]);
}


const Paula::BlepArray &BlepTables::GetAmigaTable(Resampling::AmigaFilter amigaType, bool enableFilter) const
{
	if(amigaType == Resampling::AmigaFilter::A500)
		return enableFilter ? WinSincIntegral[A500On] : WinSincIntegral[A500Off];
	if(amigaType == Resampling::AmigaFilter::A1200)
		return enableFilter ? WinSincIntegral[A1200On] : WinSincIntegral[A1200Off];
	return WinSincIntegral[Unfiltered];
}


// we do not initialize blepState here
// cppcheck-suppress uninitMemberVar
State::State(uint32 sampleRate)
{
	double amigaClocksPerSample = static_cast<double>(PAULA_HZ) / sampleRate;
	numSteps = static_cast<int>(amigaClocksPerSample / MINIMUM_INTERVAL);
	stepRemainder = SamplePosition::FromDouble(amigaClocksPerSample - numSteps * MINIMUM_INTERVAL);
	remainder = SamplePosition(0);
}


void State::Reset()
{
	remainder = SamplePosition(0);
	activeBleps = 0;
	firstBlep = MAX_BLEPS / 2u;
	globalOutputLevel = 0;
}


void State::InputSample(int16 sample)
{
	if(sample != globalOutputLevel)
	{
		// Start a new blep: level is the difference, age (or phase) is 0 clocks.
		firstBlep = (firstBlep - 1u) % MAX_BLEPS;
		if(activeBleps < std::size(blepState))
			activeBleps++;
		blepState[firstBlep].age = 0;
		blepState[firstBlep].level = sample - globalOutputLevel;
		globalOutputLevel = sample;
	}
}


// Return output simulated as series of bleps
int State::OutputSample(const BlepArray &WinSincIntegral)
{
	int output = globalOutputLevel * (1 << Paula::BLEP_SCALE);
	uint32 lastBlep = firstBlep + activeBleps;
	for(uint32 i = firstBlep; i != lastBlep; i++)
	{
		const auto &blep = blepState[i % MAX_BLEPS];
		output -= WinSincIntegral[blep.age] * blep.level;
	}
	output /= (1 << (Paula::BLEP_SCALE - 2));	// - 2 to compensate for the fact that we reduced the input sample bit depth

	return output;
}


// Advance the simulation by given number of clock ticks
void State::Clock(int cycles)
{
	uint32 lastBlep = firstBlep + activeBleps;
	for(uint32 i = firstBlep; i != lastBlep; i++)
	{
		auto &blep = blepState[i % MAX_BLEPS];
		blep.age += static_cast<uint16>(cycles);
		if(blep.age >= Paula::BLEP_SIZE)
		{
			activeBleps = static_cast<uint16>(i - firstBlep);
			return;
		}
	}
}

}

OPENMPT_NAMESPACE_END
