Engine.cpp

// Copyright (C) 2022-2026 Theo Niessink <theo@taletn.com>
// This work is free. You can redistribute it and/or modify it under the
// terms of the Do What The Fuck You Want To Public License, Version 2,
// as published by Sam Hocevar. See http://www.wtfpl.net/ for more details.

#include "Engine.h"

#include <math.h>
#include <assert.h>
#include <string.h>

namespace TG101 {

const unsigned char Engine::mPartNoTbl[kNumMidiChannels] =
{
	1, 2, 3, 4, 5, 6, 7, 8, 9, kPartDrums, 10, 11, 12, 13, 14, 15
};

const unsigned char Engine::mMidiChannelTbl[kNumParts] =
{
	9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15
};

const unsigned char Engine::mPitchModScheduleTbl[kMaxNumPoly][2] =
{
	{ 0,  25 }, { 1, 1 }, { 5, 5 }, { 9,  9 }, { 13, 13 }, { 17, 17 }, { 21, 21 },
	{ 25, 25 }, { 2, 1 }, { 6, 5 }, { 10, 9 }, { 14, 13 }, { 18, 17 }, { 22, 21 },
	{ 26, 25 }, { 3, 1 }, { 7, 5 }, { 11, 9 }, { 15, 13 }, { 19, 17 }, { 23, 21 },
	{ 27, 25 }, { 4, 1 }, { 8, 5 }, { 12, 9 }, { 16, 13 }, { 20, 17 }, { 24, 21 }
};

/* static int PitchLFOSpeed(const int speed)
{
	assert(speed >= 0 && speed <= 7);

	int period = ((speed * 146) >> 3) << 1;
	period *= (wdl_max(period, 160) >> 2) - 29;
	period = wdl_max(period, 200) << 2;
	
	return period;
} */

const unsigned short Engine::mPitchLFOSpeedTbl[8] =
{
	800,   //  1.211 Hz
	1584,  //  2.398
	3168,  //  4.796
	4752,  //  7.193
	6424,  //  9.724
	11648, // 17.632
	21800, // 33.000
	34544  // 52.292
};

const unsigned char Engine::mAltGroupTbl[kNumAltGroupTables][kNumDrumNotes] =
{
	// kDrumKitStandard
	// kDrumKitRoom
	// kDrumKitPower
	// kDrumKitElectronic
	// kDrumKitAnalog
	// kDrumKitJazz
	// kDrumKitBrush
	{
		0,  0,  29, 30, 31, 32, 33, 34, 35, 36,
		37, 38, 39, 40, 41, 42, 43, 42, 45, 42,
		47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
		57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
		67, 68, 69, 70, 71, 71, 73, 73, 75, 76,
		77, 78, 78, 80, 80, 82, 0,  0,  85, 86,
		86, 0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0
	},

	// kDrumKitOrchestra
	{
		27, 27, 27, 30, 31, 32, 33, 34, 35, 36,
		37, 38, 39, 40,	41, 42, 43, 44, 45, 46,
		47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
		57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
		67, 68, 69, 70, 71, 71, 73, 73, 75, 76,
		77, 78, 78, 80, 80, 82, 0,  0,  85, 86,
		86, 0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0
	},

	// kDrumKitClavinova
	{
		0,  0,  0,  30, 0,  32, 0,  34, 35, 36,
		37, 38, 39, 40, 41, 42, 43, 30, 45, 32,
		47, 48, 32, 50, 32, 52, 53, 54, 55, 56,
		57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
		67, 68, 69, 70, 71, 72, 73, 0,  75, 76,
		77, 78, 79, 80, 81, 80, 0,  0,  0,  0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0
	},

	// kDrumKitRX
	{
		27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
		37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
		47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
		57, 58, 57, 60, 61, 62, 63, 64, 65, 66,
		67, 68, 69, 70, 0,  0,  73, 74, 75, 0,
		0,  78, 0,  0,  0,  0,  0,  84, 85, 86,
		87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
		97, 98, 0,  0,  0,  0,  0,  0,  0,  0,
		0,  0
	},

	// kDrumKitCM64
	{
		0,  0,  0,  0,  0,  0,  0,  0,  35, 36,
		37, 38, 39, 40, 41, 42, 43, 44, 45, 42,
		47, 48, 49, 50, 51, 0,  0,  54, 0,  56,
		0,  0,  0,  60, 61, 62, 63, 64, 65, 66,
		67, 68, 69, 70, 71, 72, 73, 0,  75, 0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0
	}
};

const unsigned char Engine::mReverbTimeOffsetTbl[3][4] =
{
	{ 3,  5,  9,  15 }, // Hall
	{ 14, 18, 22, 25 }, // Room
	{ 21, 25, 33, 36 }  // Plate
};

static const int kSystemSize =
	sizeof(System) + sizeof(MultiCommon);

const int Engine::kStateSize =
	kSystemSize +
	kNumParts * sizeof(MultiPart) +
	kNumInternalVoices * sizeof(VoiceCommon) +
	kNumDrumNotes * sizeof(DrumSetup);

static inline void UpdateRand(unsigned char& state)
{
	state = state * 179 + 17;
}

template <class T> static T Clamp(T value, const T minValue, const T maxValue)
{
	assert(minValue < maxValue);

	value = wdl_max(value, minValue);
	return wdl_min(value, maxValue);
}

static int MoveToBack(unsigned char* const list, size_t idx, size_t num)
{
	assert(idx < num && num >= 1 && num < 32);

	const int c = list[idx];

	const size_t end = --num;
	num -= idx;

	if (num & 16)
	{
		num &= 15;

		WDL_UINT64 xmmword[2];
		memcpy(xmmword, &list[idx + 1], 16);
		memcpy(&list[idx], xmmword, 16);

		idx += 16;
	}

	if (num & 8)
	{
		num &= 7;

		WDL_UINT64 qword;
		memcpy(&qword, &list[idx + 1], 8);
		memcpy(&list[idx], &qword, 8);

		idx += 8;
	}

	if (num & 4)
	{
		num &= 3;

		unsigned int dword;
		memcpy(&dword, &list[idx + 1], 4);
		memcpy(&list[idx], &dword, 4);

		idx += 4;
	}

	if (num & 2)
	{
		num &= 1;

		unsigned short word;
		memcpy(&word, &list[idx + 1], 2);
		memcpy(&list[idx], &word, 2);

		idx += 2;
	}

	if (num /* & 1 */)
	{
		list[idx] = list[idx + 1];
	}

	list[end] = c;

	return c;
}

static void RemoveFromFront(unsigned char* const list, size_t idx, size_t num)
{
	assert(idx <= num /* && num >= 0 */ && num < 8);

	num -= idx;

	if (num & 4)
	{
		num &= 3;

		unsigned int dword;
		memcpy(&dword, &list[idx + 1], 4);
		memcpy(&list[idx], &dword, 4);

		idx += 4;
	}

	if (num & 2)
	{
		num &= 1;

		unsigned short word;
		memcpy(&word, &list[idx + 1], 2);
		memcpy(&list[idx], &word, 2);

		idx += 2;
	}

	if (num /* & 1 */)
	{
		list[idx] = list[idx + 1];
	}
}

static int MultiplyLevel(const int a, const int b)
{
	assert(a >= 0 && a <= 127);
	assert(b >= 0 && b <= 127);

	const unsigned int y = a*b;
	return ((y - 1) < 127) + (y >> 7);
}

template <class T> inline void Engine::IntOsc<T>::Init()
{
	mPhase = mPeriod = 0;
}
 
template <class T> inline void Engine::IntOsc<T>::Reset()
{
	mPhase = 0;
}
 
template <class T> void Engine::IntOsc<T>::SetPeriod(double period)
{
	assert(period >= 0.0 && period < 1.0);

	if (period >= 1.0) period -= floor(period);

	static const T scale = (T)1 << ((sizeof(T) - 1) * 8);
	static const double mul = (double)scale * 256.0;

	mPeriod = (T)(period * mul);
}

template <class T> inline bool Engine::IntOsc<T>::IncPhase()
{
	T phase = mPhase;
	const T period = mPeriod;

	mPhase = phase += period;
	const bool hasWrapped = phase < period;

	return hasWrapped;
}

inline int Engine::WaveData::GetPartNo(const int flags) const
{
	assert(flags == (flags & (kFlagLegato | kFlagHold1)));
	return (flags | 15) & mPartNo;
}

const VoiceElement* Engine::WaveData::GetElement() const
{
	assert(mPartNo != kPartDrums);
	return mVoice->GetElement(mElem & 1);
}

Engine::Engine()
{
	mSamplePeriod = 0.0f;

	mPitchModTimer.Init();
	mNoteOnTimer.Init();
	mReverbStateTimer.Init();
	mNoteOffTimer.Init();

	mReverbState = kReverbStateInit;
	mReverbOutputLevel = 0;

	memset(mParamChange, 0, sizeof(mParamChange));
}

bool Engine::LoadFirmware(const char* const filename, const void* const sha1, WDL_Mutex* const mutex)
{
	const bool status = mFirmware.LoadFile(filename, sha1, mutex);
	if (!status) return false;

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		mWaveGen[i].Reset();
	}

	ResetTimers();

	ResetWaveData();
	ResetPartData(true);

	mSystem.Init();
	mMultiCommon.Init();

	ResetMultiPart();
	ResetVoiceMemory();

	LoadDefaultPrograms(true);

	const int level = mMultiCommon.GetReverbOutputLevel();
	mReverb.SetOutputLevel(level);

	return true;
}

bool Engine::LoadWaveTbl(const char* const filename, const void* const sha1, WDL_Mutex* const mutex)
{
	return mWaveTbl.LoadFile(filename, sha1, mutex);
}

bool Engine::SetSampleRate(const double sampleRate, WDL_Mutex* const mutex)
{
	assert(mFirmware.GetStatus() == true);
	assert(sampleRate > 0.0);

	const double samplePeriod = 1.0 / sampleRate;
	mSamplePeriod = samplePeriod;

	mReverb.SetSampleRate(sampleRate);

	const int type = mMultiCommon.GetReverbType();
	const int time = mMultiCommon.GetReverbTime();

	mReverb.SetReverbType(type);
	SetReverbTime(type, time);

	mReverbState = kReverbStateIdle;
	mReverbType = type;
	mReverbTime = time;

	mPitchModTimer.SetPeriod(samplePeriod * 1388.8888888888889); // 1/(0.72 ms)
	mNoteOnTimer.SetPeriod(samplePeriod * 488.28125); // 1/(2.048 ms)
	mReverbStateTimer.SetPeriod(samplePeriod * 76.932545544066962); // 1/(12.9984 ms)
	mNoteOffTimer.SetPeriod(samplePeriod * 10.0); // 1/(100 ms)

	return mWaveTbl.Resample(sampleRate, mutex);
}

void Engine::Reset()
{
	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		mWaveGen[i].Reset();
	}

	do
	{
		ProcessReverbState();
	}
	while (mReverbState > kReverbStateIdle);

	mReverb.Reset();

	ResetTimers();
	ResetWaveData();

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		mAllocList[i] = i;
	}
}

void Engine::ResetTimers()
{
	mPitchModTimer.Reset();
	mNoteOnTimer.Reset();
	mReverbStateTimer.Reset();
	mNoteOffTimer.Reset();
}

void Engine::ProcessAudio(float* const outL, float* const outR, const int nFrames)
{
	ProcessAudio<float>(outL, outR, nFrames);
}

void Engine::ProcessAudio(double* const outL, double* const outR, const int nFrames)
{
	ProcessAudio<double>(outL, outR, nFrames);
}

template <class T> void Engine::ProcessAudio(T* const outL, T* const outR, const int nFrames)
{
	assert(GetStatus() == true);

	const double samplePeriod = mSamplePeriod;

	for (int i = 0; i < nFrames; ++i)
	{
		float out[2] = { 0.0f, 0.0f };
		float send = 0.0f;

		for (int j = 0; j < kMaxNumPoly; ++j)
		{
			WaveGen* const waveGen = &mWaveGen[j];
			if (!waveGen->IsActive()) continue;

			float stereo[2];
			const float mono = waveGen->GetSample(stereo, samplePeriod);

			out[0] += stereo[0];
			out[1] += stereo[1];

			send += mono;
		}

		float reverb[2];
		mReverb.Process(send, reverb);

		outL[i] = (T)out[0] + (T)reverb[0];
		outR[i] = (T)out[1] + (T)reverb[1];

		if (mPitchModTimer.IncPhase()) ProcessPitchMod();
		if (mNoteOnTimer.IncPhase()) ProcessNoteOnCounters();
		if (mReverbStateTimer.IncPhase()) ProcessReverbState();
		if (mNoteOffTimer.IncPhase()) ProcessNoteOffCounters();
	}
}

void Engine::ProcessPitchMod()
{
	int idx = mPitchModIdx;
	idx = ++idx < kMaxNumPoly ? idx : 0;
	mPitchModIdx = idx;

	int i = mPitchModScheduleTbl[idx][0];
	int updateIdx = -1;

	if (mWaveGen[i].IsActive())
	{
		WaveData* const waveData = &mWaveData[i];

		if (waveData->GetPartNo() != kPartDrums)
		{
			bool update = ProcessPitchEG(waveData);
			update |= ProcessPitchLFO(waveData);

			if (update) updateIdx = i;
		}
	}

	i = mPitchModScheduleTbl[idx][1];

	for (int j = 0; j < 4; ++j)
	{
		WaveGen* const waveGen = &mWaveGen[i];

		if (waveGen->IsActive())
		{
			WaveData* const waveData = &mWaveData[i];
			bool update = false;

			if (waveData->GetPartNo() != kPartDrums)
			{
				update = ProcessPortamento(waveData);
			}

			if (update || i == updateIdx)
			{
				UpdatePitchMod(waveGen, waveData);
				UpdatePitch(waveGen, waveData);
			}
		}

		i = ++i < kMaxNumPoly ? i : 0;
	}
}

bool Engine::ProcessPitchEG(WaveData* const waveData)
{
	static const unsigned int update =
		(1 << kPEGStateAttack) |
		(1 << kPEGStateDecay1) |
		(1 << kPEGStateDecay2) |
		(1 << kPEGStateRelease);

	int state = waveData->mPEGState;
	if (!((update >> state) & 1)) return false;

	int rate = waveData->mPEGRate;
	int level = waveData->mPEGLevel;

	const int target = waveData->mPEGTarget;
	rate = level == target ? 255 : rate;

	if (rate < 255)
	{
		rate <<= 1;

		if (level < target)
		{
			level += rate;

			if (level < wdl_min(target, +16385))
			{
				waveData->mPEGLevel = level;
				return true;
			}
		}
		else // if (level > target)
		{
			level -= rate;

			if (level > wdl_max(target, -16385))
			{
				waveData->mPEGLevel = level;
				return true;
			}
		}
	}

	int velocity = waveData->mVelocity;
	const VoiceCommon* const voice = waveData->mVoice;

	waveData->mPEGState = ++state;
	waveData->mPEGLevel = target;

	if ((update >> state) & 1)
	{
		const VoiceElement* const element = voice->GetElement(waveData->mElem & 1);

		const int range = element->GetPitchEGRange();
		velocity = element->GetPitchEGVelocitySwitch() ? 0 : velocity;

		rate = element->GetPitchEGRate(state);
		level = element->GetPitchEGLevel(++state);

		waveData->mPEGRate = ApplyPitchEGRateScale(rate, velocity, waveData->mPEGRateScale);
		waveData->mPEGTarget = ApplyPitchEGRange(level, velocity, range);
	}

	return true;
}

int Engine::ApplyPitchEGRateScale(int rate, const int velocity, const int rateScale) const
{
	assert(rate >= 0 && rate <= 63);
	assert(velocity >= 0 && velocity <= 127);
	assert(rateScale >= 0 && rateScale <= 511);

	if (!(rate < 63)) return 255;
	rate = mFirmware.LookupPitchEGRate(rate);

	if (velocity)
	{
		rate = (unsigned int)((velocity < 124 ? velocity : 127) * rate) >> 7;
		rate = wdl_max(rate, 1);
	}

	rate += rateScale;
	rate = wdl_min(rate, 254);

	return rate;
}

int Engine::ApplyPitchEGRange(int level, const int velocity, int range)
{
	assert(level >= 0 && level <= 127);
	assert(velocity >= 0 && velocity <= 127);
	assert(range >= 0 && range <= 3);

	level <<= 1;
	level = level < 254 ? level : 255;

	if (velocity)
	{
		level = (((level - 128) * velocity) / 128) + ((unsigned int)level >> 7) + 127;
	}

	level += (unsigned int)(level + 1) >> 8;
	range += (unsigned int)(range + 1) >> 2;

	return ((level - 128) << 8) >> (5 - range);
}

bool Engine::ProcessPitchLFO(WaveData* const waveData)
{
	const VoiceElement* const element = waveData->GetElement();
	const int wave = element->GetPitchLFOWave();

	bool update = false;

	if (wave) // == kPitchLFOSampleHold
	{
		update = waveData->mPitchLFO.IncPhase();
		if (update) UpdateRand(waveData->mRand);
	}

	const int flags = waveData->mLFOFlags;

	if (flags & kFlagLFODelay)
	{
		update = waveData->mLFODelay.IncPhase();
		if (update) waveData->mLFOFlags = flags & ~kFlagLFODelay;
	}

	return update;
}

bool Engine::ProcessPortamento(WaveData* const waveData)
{
	int count = waveData->mPortaCount;
	if (!count) return false;

	if (--count)
	{
		waveData->mPortaCount = count;
		return false;
	}

	int pitch = waveData->mPortaPitch;

	const int delta = pitch < 0 ? +10 : -10;
	pitch += pitch ? delta : 0;

	if (pitch)
	{
		const int partNo = waveData->GetPartNo();
		const int portaTime = mPartData[partNo].mPortaTime;
		count = mFirmware.LookupPortamentoTime(portaTime);
	}

	waveData->mPortaCount = count;
	waveData->mPortaPitch = pitch;

	return true;
}

void Engine::UpdatePitchMod(WaveGen* const waveGen, WaveData* const waveData)
{
	const int partNo = waveData->GetPartNo();

	const VoiceCommon* const voice = waveData->mVoice;
	const VoiceElement* const element = waveData->GetElement();

	int pitchMod = ((waveData->mPEGLevel * 75) >> 10) << 2;
	pitchMod += waveData->mPortaPitch;

	if (waveData->mLFOFlags & kFlagLFODelay)
	{
		waveData->mPitchMod = pitchMod;
		return;
	}

	const PartData* const partData = &mPartData[partNo];
	const MultiPart* const multiPart = &mMultiPart[partNo];

	unsigned int mod = partData->mModWheel;
	unsigned int caf = partData->mAftertouch;

	unsigned int depth = multiPart->GetLFODepth() - 64 + element->GetLFOPitchModDepth();
	depth = wdl_max((int)depth, 0);

	mod = (mod * multiPart->GetModLFOPitchDepth() * voice->GetModLFOPitchDepth()) >> 8;
	caf = (caf * multiPart->GetAftertouchLFOPitchDepth() * voice->GetAftertouchLFOPitchDepth()) >> 8;

	if (element->GetPitchLFOWave() == kPitchLFOTriangle)
	{
		mod = (mod * 147) >> 7;
		caf = (caf * 147) >> 7;

		depth = (depth >> 1) + ((mod + caf) >> 4);
		depth = wdl_min(depth, 7);

		if (waveData->mVibratoDepth != depth)
		{
			waveData->mVibratoDepth = depth;
			waveGen->SetVibratoDepth(depth);
		}
	}
	else // if (element->GetPitchLFOWave() == kPitchLFOSampleHold)
	{
		mod = (mod * 589) >> 8;
		caf = (caf * 589) >> 8;

		depth = ((depth * 17) & ~1) + mod + caf;
		depth = wdl_min(depth, 255);

		pitchMod += (waveData->mRand * depth) >> 7; 
	}

	waveData->mPitchMod = pitchMod;
}

void Engine::UpdatePitch(WaveGen* const waveGen, const WaveData* const waveData)
{
	int pitch = waveData->mPitch + waveData->mDetune + waveData->mPitchBend + waveData->mCAFPitch + waveData->mPitchMod;
	assert(pitch >= -9600 && pitch < +8400);

	const int oct = ((pitch >= 0 ? 1200 : 1) + pitch) / 1200;
	pitch -= (oct - 1) * 1200;

	const int fNumber = mFirmware.LookupPitch(pitch);
	waveGen->SetPitch(oct, fNumber);
}

void Engine::ProcessNoteOnCounters()
{
	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		int counter = mNoteOnCounter[i];
		if (!counter) continue;

		mNoteOnCounter[i] = --counter;

		if (!counter)
		{
			WaveGen* const waveGen = &mWaveGen[i];
			WaveData* const waveData = &mWaveData[i];

			LoadWave(waveGen, waveData);
			KeyOn(waveGen, waveData);
		}
	}
}

void Engine::LoadWave(WaveGen* const waveGen, const WaveData* const waveData)
{
	const int waveTblIdx = waveData->mWaveTblIdx;

	const WaveTblHeader* const header = mWaveTbl.GetHeader(waveTblIdx);
	const float* const samplePtr = mWaveTbl.GetSamplePtr(waveTblIdx);

	waveGen->LoadWave(header, samplePtr, mSamplePeriod);

	waveGen->SetTotalLevel(waveData->mTotalLevel, false);
	waveGen->SetPan(waveData->mPan);

	waveGen->SetReverbDepth(waveData->mReverb);
}

void Engine::KeyOn(WaveGen* const waveGen, WaveData* const waveData)
{
	const int partNo = waveData->GetPartNo();

	if (partNo != kPartDrums)
	{
		const int legato = waveData->mPartNo & kFlagLegato;

		const int note = waveData->mNote, velocity = waveData->mVelocity;
		const VoiceElement* const element = waveData->GetElement();

		if (!legato) AttackPitchEG(waveData, note, velocity, element);

		const MultiPart* const multiPart = &mMultiPart[partNo];

		int attack = waveData->mEGRate >> 4;
		int release = waveData->mEGRate & 15;

		attack += multiPart->GetEGAttackRate() + element->GetEGAttackRate() - 2*64;
		release += multiPart->GetEGReleaseRate() + element->GetEGReleaseRate() - 2*64;

		attack = Clamp(attack, 1, 15);
		release = Clamp(release, 1, 15);

		waveGen->SetEGAttackRate(attack);
		waveGen->SetEGReleaseRate(release);

		int lfoSpeed = multiPart->GetLFOSpeed() - 64 + element->GetLFOSpeed();
		lfoSpeed = Clamp(lfoSpeed, 0, 7);
		waveGen->SetLFOSpeed(lfoSpeed, mSamplePeriod);

		int ampModDepth = multiPart->GetLFODepth() - 64 + (element->GetLFOAmpModDepth() << 1);
		ampModDepth = (unsigned int)wdl_max(ampModDepth, 0) >> 1;
		ampModDepth = wdl_min(ampModDepth, 7);
		waveGen->SetTremoloDepth(ampModDepth);

		if (element->GetPitchLFOWave()) // == kPitchLFOSampleHold
		{
			waveData->mPitchLFO.mPhase = 0;
			waveData->mPitchLFO.mPeriod = mPitchLFOSpeedTbl[(unsigned int)lfoSpeed];
			UpdateRand(waveData->mRand);
		}

		int lfoDelay = multiPart->GetLFODelay() - 64 + element->GetLFODelay();
		lfoDelay = Clamp(lfoDelay, 0, 127);

		waveData->mLFOFlags = lfoDelay ? kFlagLFODelay : 0;
		waveData->mLFODelay.mPhase = 0;
		waveData->mLFODelay.mPeriod = ScaleLFODelay(lfoDelay);
		waveData->mVibratoDepth = 0;

		UpdatePitchMod(waveGen, waveData);
	}
	else
	{
		waveData->mPitchMod = 0;
	}

	UpdatePitch(waveGen, waveData);

	waveGen->EnableLFO(partNo != kPartDrums);
	waveGen->KeyOn(mSamplePeriod);
}

void Engine::AttackPitchEG(WaveData* const waveData, int note, int velocity, const VoiceElement* const element)
{
	assert(note >= 0 && note <= 127);
	assert(velocity >= 1 && velocity <= 127);

	const int range = element->GetPitchEGRange();
	velocity = element->GetPitchEGVelocitySwitch() ? 0 : velocity;

	note -= 21;
	note = wdl_max(note, 0);

	const int rateScale = (unsigned int)(element->GetPitchEGRateScale() * note) >> 2;

	int rate = element->GetPitchEGRate(kPEGRateAttack);
	int target = element->GetPitchEGLevel(kPEGLevelAttack);

	rate = ApplyPitchEGRateScale(rate, velocity, rateScale);
	int level = target = ApplyPitchEGRange(target, velocity, range);

	if (rate < 255)
	{
		level = element->GetPitchEGLevel(kPEGLevelInit);
		level = ApplyPitchEGRange(level, velocity, range);
	}

	waveData->mPEGState = kPEGStateAttack;
	waveData->mPEGRate = rate;
	waveData->mPEGLevel = level;
	waveData->mPEGTarget = target;
	waveData->mPEGRateScale = rateScale;
}

int Engine::ScaleLFODelay(int delay)
{
	assert(delay >= 0 && delay <= 127);

	if (!delay) return 0;

	const unsigned int inv = delay ^ 127;
	delay = (((inv & 15) | 16) << 11) >> (7 - (inv >> 4));

	return delay;
}

void Engine::ProcessReverbState()
{
	unsigned int state = mReverbState;

	switch (state)
	{
		case kReverbStateInit: return;

		case kReverbStateIdle:
		{
			const int type = mMultiCommon.GetReverbType();

			if (mReverbType == type)
			{
				const int time = mMultiCommon.GetReverbTime();
				const int level = mMultiCommon.GetReverbOutputLevel();

				if (mReverbTime != time)
				{
					mReverbTime = time;
					SetReverbTime(type, time);
				}

				if (mReverbOutputLevel != level)
				{
					mReverbOutputLevel = level;
					mReverb.SetOutputLevel(level);
				}
				return;
			}
			else
			{
				mReverbType = type;
				mReverb.MuteOutput();
				break;
			}
		}

		case kReverbStateLoad:
		{
			const int type = mReverbType;
			const int time = MultiCommon::GetReverbTime(type);

			mMultiCommon.SetReverbTime(time);
			const int level = mMultiCommon.GetReverbOutputLevel();

			mReverbTime = time;
			mReverbOutputLevel = level;

			mReverb.SetReverbType(type);
			SetReverbTime(type, time);
			break;
		}

		case kReverbStateUnmute:
		{
			mReverbState = kReverbStateIdle;
			const int level = mReverbOutputLevel;

			mReverb.SetOutputLevel(level);
			return;
		}
	}

	mReverbState = ++state;
}

void Engine::SetReverbTime(int type, const int time)
{
	assert(type >= 0 /* && type < kNumReverbTypes */);

	const int num = type < kReverbDelay1 ? 4 : 3;
	type = type <= kReverbPlate2 ? type : kReverbHall1;

	const unsigned char* const ofs = mReverbTimeOffsetTbl[(unsigned int)type >> 1];
	const int idx = mFirmware.LookupReverbTime(time);

	unsigned short coeff[4][2];

	for (int i = 0; i < num; ++i)
	{
		const int j = ofs[i] + idx;

		coeff[i][0] = mFirmware.LookupReverbFeedback(j);
		coeff[i][1] = mFirmware.LookupReverbGain(j);
	}

	mReverb.SetReverbFeedback(coeff, num);
}

void Engine::ProcessNoteOffCounters()
{
	int n = mNumNoteOffCounters;
	if (!n) return;

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		int counter = mNoteOffCounter[i];
		if (!counter) continue;

		mNoteOffCounter[i] = --counter;

		if (!counter)
		{
			mWaveGen[i].KeyOff(mSamplePeriod);

			mNoteOnCounter[i] = 0;
			mNumNoteOffCounters = --n;

			mWaveData[i].mNote = 0x80;

			if (!n) break;
		}
	}
}

EMidiStatus Engine::ProcessMidiMsg(const unsigned char* const msg)
{
	assert(GetStatus() == true);

	int status = (msg[0] >> 4) ^ 8;
	const int midiCh = msg[0] & 15;

	switch ((unsigned int)status)
	{
		case kMidiNoteOff:
		case kMidiNoteOn:
		{
			const int note = msg[1], velocity = msg[2];
			status = velocity ? status : kMidiNoteOff;

			if (status == kMidiNoteOff)
				NoteOff(midiCh, note);
			else
				NoteOn(midiCh, note, velocity);
			break;
		}

		case kMidiControlChange:
		{
			ControlChange(midiCh, msg[1], msg[2]);
			break;
		}

		case kMidiProgramChange:
		{
			ProgramChange(midiCh, msg[1], true);
			break;
		}

		case kMidiChannelAftertouch:
		{
			ChannelAftertouch(midiCh, msg[1]);
			break;
		}

		case kMidiPitchBend:
		{
			PitchBend(midiCh, (msg[1] | (msg[2] << 7)) - 8192);
			break;
		}
	}

	return status;
}

void Engine::NoteOff(const int midiCh, const int note)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(note >= 0 && note <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		if (mMultiPart[partNo].GetPolyMode())
			PolyNoteOff(partNo, note);
		else
			MonoNoteOff(partNo, note);
	}
}

void Engine::PolyNoteOff(const int partNo, const int note)
{
	assert(partNo >= 1 && partNo < kNumParts);
	assert(note >= 0 && note <= 127);

	const int hold = mPartData[(unsigned int)partNo].mFlags & kFlagHold1;

	for (int i = 0, j = 0; j < kMaxNumPoly; ++j)
	{
		const int alloc = mAllocList[j];
		WaveData* const waveData = &mWaveData[(unsigned int)alloc];

		if (waveData->GetPartNo(kFlagHold1) == partNo && waveData->mNote == note)
		{
			if (hold)
			{
				waveData->mPartNo |= kFlagHold1;
				continue;
			}

			const int n = (unsigned int)ElementNoteOff(alloc) >> 1;
			if (++i > n) break;
		}
	}
}

void Engine::MonoNoteOff(const int partNo, const int note)
{
	assert(partNo >= 1 && partNo < kNumParts);
	assert(note >= 0 && note <= 127);

	MonoData* const monoData = &mMonoData[(unsigned int)partNo];
	int num = monoData->mNumNotes;

	int maxNote = -1, idx;
	bool active = false;

	for (int i = 0; i < num; ++i)
	{
		const int c = monoData->mNoteList[i];

		if (c == note)
		{
			monoData->mNumNotes = --num;

			if (i < num)
			{
				RemoveFromFront(monoData->mNoteList, i, num);
				return;
			}

			active = true;
			break;
		}
		else if (c > maxNote)
		{
			maxNote = c;
			idx = i;
		}
	}

	if (!active) return;

	PartData* const partData = &mPartData[(unsigned int)partNo];

	if (num)
	{
		const int mode = partData->mVoice->GetVoiceMode();
		const int voiceIdx = partData->mVoiceIdx;

		if (monoData->mVoiceIdx != voiceIdx)
		{
			partData->mFlags |= kFlagVelocity;
			monoData->mVoiceIdx = voiceIdx;
		}

		// monoData->mNote = maxNote;
		const int velocity = monoData->mVelocity;

		signed char elem[2];
		memcpy(elem, monoData->mAlloc, 2);

		int skip = -1;

		for (int i = 0; i <= kVoiceModeDual; ++i)
		{
			const int reuse = elem[i];
			const int alloc = i <= mode ? ElementNoteOn(partNo, maxNote, velocity, i, skip, reuse) : -1;
			elem[i] = skip = alloc;

			if (alloc < 0 && reuse >= 0)
			{
				const unsigned int j = reuse;
				mWaveGen[j].KeyOff(mSamplePeriod);

				mNoteOnCounter[j] = 0;
				mWaveData[j].mNote = 0x80;
			}
		}

		memcpy(monoData->mAlloc, elem, 2);

		RemoveFromFront(monoData->mNoteList, idx, --num);
		monoData->mNoteList[num] = maxNote;
	}
	else // if (!num)
	{
		const int hold = partData->mFlags & kFlagHold1;

		signed char elem[2];
		memcpy(elem, monoData->mAlloc, 2);

		for (int i = 0; i <= kVoiceModeDual; ++i)
		{
			const int alloc = elem[i];
			if (alloc < 0) continue;

			if (hold)
			{
				mWaveData[(unsigned int)alloc].mPartNo |= kFlagHold1;
				continue;
			}

			elem[i] = (signed char)0xFF;
			ElementNoteOff(alloc);
		}

		memcpy(monoData->mAlloc, elem, 2);
	}
}

int Engine::ElementNoteOff(const int alloc)
{
	assert(alloc >= 0 && alloc < kMaxNumPoly);
	const unsigned int idx = alloc;

	WaveGen* const waveGen = &mWaveGen[idx];
	waveGen->KeyOff(mSamplePeriod);

	mNoteOnCounter[idx] = 0;

	WaveData* const waveData = &mWaveData[idx];
	waveData->mNote = 0x80;

	const int velocity = waveData->mVelocity;
	const int elem = waveData->mElem;

	ReleasePitchEG(waveData, velocity, waveData->GetElement());
	UpdatePitchMod(waveGen, waveData);

	return elem;
}

void Engine::ReleasePitchEG(WaveData* const waveData, int velocity, const VoiceElement* const element)
{
	assert(velocity >= 1 && velocity <= 127);

	const int range = element->GetPitchEGRange();
	velocity = element->GetPitchEGVelocitySwitch() ? 0 : velocity;

	const int rate = element->GetPitchEGRate(kPEGRateRelease);
	const int level = element->GetPitchEGLevel(kPEGLevelRelease);

	waveData->mPEGRate = ApplyPitchEGRateScale(rate, velocity, waveData->mPEGRateScale);
	waveData->mPEGTarget = ApplyPitchEGRange(level, velocity, range);
}

void Engine::NoteOn(const int midiCh, const int note, int velocity)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(note >= 0 && note <= 127);
	assert(velocity >= 1 && velocity <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		const MultiPart* const multiPart = &mMultiPart[partNo];

		const int low = multiPart->GetNoteLimitLow();
		const int high = multiPart->GetNoteLimitHigh();

		if (!(note >= low && note <= high)) continue;

		if (partNo != kPartDrums)
		{
			velocity = ApplyVelocitySense(velocity, multiPart->GetVelocitySense());

			if (multiPart->GetPolyMode())
				PolyNoteOn(partNo, note, velocity);
			else
				MonoNoteOn(partNo, note, velocity);
		}
		else
		{
			DrumNoteOn(note, velocity);
		}
	}
}

int Engine::ApplyVelocitySense(int velocity, const int sense)
{
	assert(velocity >= 1 && velocity <= 127);
	assert(sense >= 0 && sense <= 15);

	velocity = 127 - ((unsigned int)((velocity ^ 127) * ((sense * 14) + 16)) >> 7);
	velocity = wdl_max(velocity, 1);

	return velocity;
}

void Engine::PolyNoteOn(const int partNo, const int note, const int velocity)
{
	assert(partNo >= 1 && partNo < kNumParts);

	const int mode = mPartData[(unsigned int)partNo].mVoice->GetVoiceMode();
	int skip = -1;

	for (int i = 0; i <= mode; ++i)
	{
		const int alloc = ElementNoteOn(partNo, note, velocity, i, skip);
		skip = alloc;
	}
}

void Engine::MonoNoteOn(const int partNo, const int note, const int velocity)
{
	assert(partNo >= 1 && partNo < kNumParts);

	PartData* const partData = &mPartData[(unsigned int)partNo];

	const int flags = partData->mFlags;
	if (flags & kFlagHold1) Hold1NotesOff(partNo);

	const int mode = partData->mVoice->GetVoiceMode();
	const int voiceIdx = partData->mVoiceIdx;

	MonoData* const monoData = &mMonoData[(unsigned int)partNo];
	int num = monoData->mNumNotes;

	if (monoData->mVoiceIdx != voiceIdx)
	{
		partData->mFlags = flags | kFlagVelocity;
		monoData->mVoiceIdx = voiceIdx;
	}

	// monoData->mNote = note;
	monoData->mVelocity = velocity;

	signed char elem[2];
	memcpy(elem, monoData->mAlloc, 2);

	int skip = -1;

	for (int i = 0; i <= kVoiceModeDual; ++i)
	{
		const int reuse = elem[i];
		const int alloc = i <= mode ? ElementNoteOn(partNo, note, velocity, i, skip, reuse) : -1;
		elem[i] = skip = alloc;

		if (alloc < 0 && reuse >= 0)
		{
			const unsigned int j = reuse;
			mWaveGen[j].KeyOff(mSamplePeriod);

			mNoteOnCounter[j] = 0;
			mWaveData[j].mNote = 0x80;
		}
	}

	memcpy(monoData->mAlloc, elem, 2);

	if (num)
	{
		int minNote = 128, idx;
		bool found = false;

		for (int i = 0; i < num; ++i)
		{
			const int c = monoData->mNoteList[i];

			if (c == note)
			{
				idx = i;
				found = true;
				break;
			}
			else if (c < minNote)
			{
				minNote = c;
				idx = i;
			}
		}

		if (found || !(num < kMaxNumMono))
		{
			RemoveFromFront(monoData->mNoteList, idx, --num);
		}
	}

	monoData->mNumNotes = num + 1;
	monoData->mNoteList[num] = note;
}

int Engine::ElementNoteOn(const int partNo, const int note, int velocity, const int elem, const int skip, const int reuse)
{
	assert(partNo >= 1 && partNo < kNumParts);
	assert(note >= 0 && note <= 127);
	assert(velocity >= 1 && velocity <= 127);

	PartData* const partData = &mPartData[(unsigned int)partNo];
	const MultiPart* const multiPart = &mMultiPart[(unsigned int)partNo];

	const VoiceCommon* const voice = partData->mVoice;
	const VoiceElement* const element = voice->GetElement(elem);

	int coarse, fine;
	coarse = ApplyPitchRateScale(voice->GetPitchRateScale(elem), voice->GetPitchRateScaleCenter(elem), note, &fine);

	const int detune = mSystem.GetMasterTune() + multiPart->GetDetune() - 2*128;

	coarse += mSystem.GetTranspose() + multiPart->GetNoteShift() + voice->GetNoteShift(elem) - 3*64;
	fine += voice->GetDetune(elem) - 64;

	coarse = Clamp(coarse, 0, 127);

	const SampleSet* sampleSet = mFirmware.FindSampleSet(element->GetWaveNo(), coarse);
	if (!sampleSet) return -1;

	coarse -= sampleSet->GetPitchCoarse();
	fine += sampleSet->GetPitchFine();

	const int flags = partData->mFlags;
	partData->mFlags = flags & ~kFlagVelocity;

	int legato = 0, alloc = reuse;

	if (reuse < 0)
		alloc = MoveToBack(mAllocList, AllocVoice(skip), kMaxNumPoly);
	else
		legato = flags & kFlagPortamento ? kFlagLegato : 0;

	if (!legato) FastRelease(&mWaveGen[alloc]);

	mNoteOnCounter[alloc] = 3;
	mNoteOffCounter[alloc] = 0;

	WaveData* const waveData = &mWaveData[alloc];

	waveData->mPartNo = legato | partNo;
	waveData->mNote = note;

	if (!legato || (flags & kFlagVelocity))
		waveData->mVelocity = velocity;
	else
		velocity = waveData->mVelocity;

	const int mode = voice->GetVoiceMode();
	waveData->mElem = (mode << 1) | elem;

	waveData->mAltGroup = 0xFFFF;
	waveData->mWaveTblIdx = sampleSet->GetWaveTblIdx();
	waveData->mVoice = voice;

	const int attack = sampleSet->GetEGAttackRate() << 4;
	const int release = sampleSet->GetEGReleaseRate();
	waveData->mEGRate = attack | release;

	int portaTime = partData->mPortaTime;
	int portaPitch = partData->mPortaNote - note;
	if (elem == mode) partData->mPortaNote = note;

	portaPitch = Clamp(portaPitch, -1, +1);
	portaPitch = (flags & kFlagPortamento) && portaTime ? portaPitch : 0;

	waveData->mPortaCount = portaTime ? mFirmware.LookupPortamentoTime(portaTime) : 0;
	waveData->mPortaPitch = portaPitch * 100;

	waveData->mPitch = coarse * 100 + fine;
	waveData->mDetune = detune;

	waveData->mPitchBend = GetPitchBend(partData->mPitchBend, multiPart->GetPitchBendRange());
	waveData->mCAFPitch = GetAftertouchPitch(partData->mAftertouch, multiPart->GetAftertouchPitchControl());

	int level = voice->GetLevel(elem) + ApplyLevelScale(element, note) - 128;
	level = Clamp(level, 0, 127);

	const int curve = element->GetVelocityCurve();
	velocity = mFirmware.LookupVelocity(curve, velocity) - sampleSet->GetAttenuation();
	velocity = wdl_max(velocity, 0);

	waveData->mElemLevel = level;
	waveData->mVeloLevel = velocity;
	waveData->mTotalLevel = GetTotalLevel(level, velocity, partData->mExpression, multiPart->GetVolume());

	int partPan = partData->mPan;

	if (multiPart->GetPan() == kPanVoice)
	{
		int elemPan = element->GetPan();
		elemPan += elemPan == kPanVoice;

		elemPan = (elemPan ^ 8) - ((unsigned int)elemPan >> 3);

		partPan += elemPan;
		partPan = Clamp(partPan, 0, 15);

		partPan ^= 8;
		partPan = (((unsigned int)partPan >> 3) + partPan) & 15;
	}

	assert(partPan != kPanVoice);
	waveData->mPan = partPan;

	const int reverb = multiPart->GetReverbSendDepth();
	waveData->mReverb = reverb;

	return alloc;
}

int Engine::ApplyPitchRateScale(int rateScale, const int center, const int note, int* const pFine)
{
	assert(rateScale >= 0 && rateScale <= 5);
	assert(center >= 0 && center <= 127);
	assert(note >= 0 && note <= 127);
	
	int coarse = rateScale == kPitchRateScale100 ? note : center;
	int fine = 0;

	if ((unsigned int)--rateScale < 4)
	{
		static const unsigned char tbl[4] = { 50, 20, 10, 5 };
		rateScale = tbl[(unsigned int)rateScale];

		int cent = (note - center) * rateScale + 127*100;
		assert(cent >= 0);

		const int semi = (unsigned int)cent / 100;
		cent = (unsigned int)cent % 100;

		coarse += semi - 127;
		fine = cent;
	}

	*pFine = fine;
	return coarse;
}

int Engine::AllocVoice(const int skip) const
{
	int idx, prio = -1;

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		const int alloc = mAllocList[i];
		if (alloc == skip) continue;

		const WaveData* const waveData = &mWaveData[alloc];

		int partNo = waveData->mPartNo;
		const int note = waveData->mNote;

		const int hold = partNo & kFlagHold1 ? 16 : 0;
		const int avail = note & 0x80;

		if (avail)
		{
			idx = i;
			break;
		}

		partNo = (partNo & 15) | hold;

		if (partNo > prio)
		{
			idx = i;
			prio = partNo;
		}
	}

	return idx;
}

void Engine::FastRelease(WaveGen* const waveGen)
{
	waveGen->SetEGReleaseRate(15);
	waveGen->SetEGRateScale(15);

	waveGen->EnableLFO(false);
	waveGen->KeyOff(mSamplePeriod);
}

int Engine::ApplyLevelScale(const VoiceElement* const element, const int note)
{
	assert(note >= 0 && note <= 127);

	int bp[4];

	bp[0] = element->GetLevelScaleBreakPoint(0);
	if (note <= bp[0]) return element->GetLevelScaleOffset(0);

	for (int i = 1; i <= 2; ++i)
	{
		bp[i] = element->GetLevelScaleBreakPoint(i);
	}

	bp[3] = element->GetLevelScaleBreakPoint(3);
	if (note >= bp[3]) return element->GetLevelScaleOffset(3);

	int ofs = 128;

	for (int i = 2; i >= 0; --i)
	{
		if (note < bp[i]) continue;

		const int j = i + 1;

		const int ofs0 = element->GetLevelScaleOffset(i);
		const int ofs1 = element->GetLevelScaleOffset(j);

		ofs = ((ofs1 - ofs0) * (note - bp[i])) / (bp[j] - bp[i]) + ofs0;

		ofs = wdl_max(ofs, 0);
		ofs = wdl_min(ofs, 255);
		break;
	}

	return ofs;
}

void Engine::DrumNoteOn(const int note, int velocity)
{
	assert(note >= 0 && note <= 127);
	assert(velocity >= 1 && velocity <= 127);

	if (mNumNoteOffCounters >= kMaxNumPoly) return;

	const PartData* const partData = &mPartData[kPartDrums];
	const MultiPart* const multiPart = &mMultiPart[kPartDrums];

	const DrumKit* const drumKit = partData->mDrumKit;

	const int soundIdx = drumKit->GetDrumSoundIdx(note);
	if (soundIdx >= kDrumSoundOff) return;

	const DrumSound* const drumSound = mFirmware.GetDrumSound(soundIdx);

	const int detune = mSystem.GetMasterTune() + multiPart->GetDetune() - 2*128;
	const int coarse = mSystem.GetTranspose() + multiPart->GetNoteShift() + drumSound->GetPitchCoarse() - 2*64;
	const int fine = drumSound->GetPitchFine();

	assert(note >= kDrumNoteMin && note <= kDrumNoteMax);
	const unsigned int inst = note - kDrumNoteMin;

	const DrumSetup* const drumSetup = &mDrumSetup[inst];
	const int altGroup = mAltGroup[inst];

	const int alloc = MoveToBack(mAllocList, AllocDrumVoice(altGroup), kMaxNumPoly);
	FastRelease(&mWaveGen[alloc]);

	WaveData* const waveData = &mWaveData[alloc];

	mNoteOnCounter[alloc] = 3;
	mNoteOffCounter[alloc] = 10;

	waveData->mPartNo = kPartDrums;
	waveData->mNote = note;
	waveData->mVelocity = velocity;

	static const int mode = kVoiceModeSingle, elem = kVoiceElement1;
	waveData->mElem = (mode << 1) | elem;

	waveData->mAltGroup = altGroup;
	waveData->mWaveTblIdx = drumSound->GetWaveTblIdx();
	waveData->mDrumSound = drumSound;

	waveData->mPitch = coarse * 100 + fine;
	waveData->mDetune = detune;
 	waveData->mPitchBend = 0;

	const int level = drumSetup->GetLevel();

	static const int curve = 2;
	velocity = mFirmware.LookupVelocity(curve, velocity) - drumSound->GetAttenuation();
	velocity = wdl_max(velocity, 0);

	waveData->mElemLevel = level;
	waveData->mVeloLevel = velocity;
	waveData->mTotalLevel = GetTotalLevel(level, velocity, partData->mExpression, multiPart->GetVolume());

	int partPan = multiPart->GetPan();
	int drumPan = drumSetup->GetPan();

	drumPan += drumPan == kPanVoice;

	if (partPan != kPanVoice)
	{
		assert(partPan == partData->mPan);

		partPan -= partPan > 8 ? 16 : 0;
		drumPan -= drumPan > 8 ? 16 : 0;

		drumPan += partPan;
		drumPan = Clamp(drumPan, -7, +7);

		drumPan += drumPan < 0 ? 16 : 0;
	}

	assert(drumPan != kPanVoice);
	waveData->mPan = drumPan;

	const int reverb = multiPart->GetReverbSendDepth() + drumSetup->GetReverbDepth() - 4;
	waveData->mReverb = Clamp(reverb, 0, 8);
}

int Engine::AllocDrumVoice(const int altGroup)
{
	assert(altGroup >= 0 && altGroup < kDrumSoundOff);

	int idx = -1, prio = kPartDrums, reuse;

	#ifndef NDEBUG
	reuse = -1;
	#endif

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		const int alloc = mAllocList[i];
		const WaveData* const waveData = &mWaveData[alloc];

		int partNo = waveData->mPartNo;
		const int note = waveData->mNote;

		const int hold = partNo & kFlagHold1 ? 16 : 0;
		const int avail = note & 0x80;

		if (waveData->mAltGroup == altGroup)
		{
			mNumNoteOffCounters += !mNoteOffCounter[alloc];
			assert(mNumNoteOffCounters <= kMaxNumPoly);

			return i;
		}

		if (avail)
		{
			idx = idx < 0 ? i : idx;
			continue;
		}

		partNo = (partNo & 15) | hold;

		if (partNo > prio)
		{
			reuse = i;
			prio = partNo;
		}
	}

	idx = idx < 0 ? reuse : idx;

	assert(idx >= 0 && idx < kMaxNumPoly);
	assert(mNoteOffCounter[mAllocList[idx]] == 0);

	mNumNoteOffCounters++;
	assert(mNumNoteOffCounters <= kMaxNumPoly);

	return idx;
}

void Engine::ControlChange(const int midiCh, const int cc, const int value)
{
	switch ((unsigned int)cc)
	{
		case 0: SetBankSelect(midiCh, value); break;
		case 1: SetModWheel(midiCh, value); break;
		case 5: SetPortamentoTime(midiCh, value, true); break;
		case 6: SetDataEntryMSB(midiCh, value, true); break;
		case 7: SetVolume(midiCh, value, true); break;
		case 10: SetPan(midiCh, value, true); break;
		case 11: SetExpression(midiCh, value); break;
		case 38: SetDataEntryLSB(midiCh, value, true); break;
		case 64: SetHold1(midiCh, value); break;
		case 65: SetPortamento(midiCh, value); break;
		case 91: SetReverbDepth(midiCh, value, true); break;
		case 100: SetRegisteredParamLSB(midiCh, value); break;
		case 101: SetRegisteredParamMSB(midiCh, value); break;

		case 120: AllSoundOff(midiCh, value); break;
		case 121: ResetAllControllers(midiCh, value); break;
		case 123:
		case 124:
		case 125: AllNotesOff(midiCh, value); break;
		case 126: MonoModeOn(midiCh, value, true); break;
		case 127: PolyModeOn(midiCh, value, true); break;

		default:
		{
			assert(GetStatus() == true);
			assert(midiCh >= 0 && midiCh < kNumMidiChannels);
			assert(cc >= 0 && cc <= 127);
			assert(value >= 0 && value <= 127);
		}
	}
}

void Engine::SetBankSelect(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		mMultiPart[partNo].SetVoiceBank(value);
	}
}

void Engine::SetModWheel(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		mPartData[partNo].mModWheel = value;
		UpdatePitchModDepth(partNo);
	}
}

void Engine::UpdatePitchModDepth(const int partNo)
{
	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		WaveGen* const waveGen = &mWaveGen[i];
		if (!waveGen->IsActive()) continue;

		WaveData* const waveData = &mWaveData[i];
		if (waveData->GetPartNo() != partNo) continue;

		if (waveData->mLFOFlags & kFlagLFODelay) continue;

		UpdatePitchMod(waveGen, waveData);
		UpdatePitch(waveGen, waveData);
	}
}

void Engine::SetPortamentoTime(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];
	bool change = false;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		mPartData[partNo].mPortaTime = value;
		change = partNo != kPartDrums ? paramChange : change;
	}

	if (!change) return;

	SetParamChange(kParamChannelPortamentoTime, midiCh);
	mParamChange[2] = value;
}

void Engine::SetVolume(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if (!mSystem.IsEnabled(kEnableControlChange)) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];
	bool change = false;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		mMultiPart[partNo].SetVolume(value);
		UpdateTotalLevel(partNo, mPartData[partNo].mExpression, value);

		change = paramChange;
	}

	if (!change) return;

	SetParamChange(kParamChannelVolume, midiCh);
	mParamChange[2] = value;
}

void Engine::SetExpression(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if (!mSystem.IsEnabled(kEnableControlChange)) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		mPartData[partNo].mExpression = value;
		UpdateTotalLevel(partNo, value, mMultiPart[partNo].GetVolume());
	}
}

void Engine::UpdateTotalLevel(const int partNo, const int expr, const int vol)
{
	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		WaveGen* const waveGen = &mWaveGen[i];
		if (!waveGen->IsActive()) continue;

		WaveData* const waveData = &mWaveData[i];
		if (waveData->GetPartNo() != partNo) continue;

		const int level = GetTotalLevel(waveData->mElemLevel, waveData->mVeloLevel, expr, vol);
		waveData->mTotalLevel = level;

		waveGen->SetTotalLevel(level, true);
	}
}

int Engine::GetTotalLevel(int level, const int velo, const int expr, const int vol) const
{
	assert(level >= 0 && level <= 127);
	assert(velo >= 0 && velo <= 127);
	assert(vol >= 0 && vol <= 127);
	assert(expr >= 0 && expr <= 127);

	level = MultiplyLevel(level, mSystem.GetMasterVolume());
	level = MultiplyLevel(level, vol);
	level = MultiplyLevel(level, expr);

	level = mFirmware.LookupVolume(level);

	return MultiplyLevel(level, velo);
}

void Engine::SetPan(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	const int unipolar = (value & 64 ? 0 : 1) + ((unsigned int)value >> 3);
	const int pan = unipolar ^ 8, bipolar = unipolar - 8;

	bool change = false, drumVoicePan = false;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		PartData* const partData = &mPartData[partNo];
		MultiPart* const multiPart = &mMultiPart[partNo];

		if (multiPart->GetPan() != kPanVoice)
		{
			partData->mPan = pan;
			multiPart->SetPan(pan);
		}
		else
		{
			partData->mPan = bipolar;
			drumVoicePan = partNo == kPartDrums ? true : drumVoicePan;
		}

		change = paramChange;
	}

	if (!change) return;

	SetParamChange(kParamChannelPan, midiCh);

	mParamChange[2] = pan;
	mParamChange[3] = value;
	mParamChange[4] = drumVoicePan;
}

void Engine::SetHold1(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartData* const partData = &mPartData[partNo];

		if (value & 64)
		{
			partData->mFlags |= kFlagHold1;
		}
		else
		{
			partData->mFlags &= ~kFlagHold1;

			const int n = Hold1NotesOff(partNo);
			if (n) memset(mMonoData[partNo].mAlloc, 0xFF, 2);
		}
	}
}

int Engine::Hold1NotesOff(const int partNo)
{
	assert(partNo >= 1 && partNo < kNumParts);

	const int hold = partNo | kFlagHold1;
	int n = 0;

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		WaveData* const waveData = &mWaveData[i];

		if (waveData->GetPartNo(kFlagHold1) != hold) continue;
		waveData->mPartNo ^= kFlagHold1;

		mWaveGen[i].KeyOff(mSamplePeriod);

		mNoteOnCounter[i] = 0;
		waveData->mNote = 0x80;

		n++;
	}

	return n;
}

void Engine::SetPortamento(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];
	const int porta = value & 64 ? kFlagPortamento : 0;

	for (;;)
	{
		int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartData* const partData = &mPartData[partNo];
		partData->mFlags = (partData->mFlags & ~kFlagPortamento) | porta;
	}
}

void Engine::SetReverbDepth(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];
	const int depth = (value << 3) / 114;

	bool change = false;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		MultiPart* const multiPart = &mMultiPart[partNo];
		multiPart->SetReverbSendDepth(depth);

		change = paramChange;
	}

	if (!change) return;

	SetParamChange(kParamChannelReverbDepth, midiCh);

	mParamChange[2] = depth;
	mParamChange[3] = value;
}

#define RPN(msb, lsb) (((msb) << 7) | (lsb))

void Engine::SetRegisteredParamLSB(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartData* const partData = &mPartData[partNo];

		const int msb = partData->mRegParamMSB;
		partData->mRegParamLSB = value;

		if (RPN(msb, value) == RPN(0x7F, 0x7F))
		{
			partData->mRegParamMSB = 0xFF;
			partData->mRegParamLSB = 0xFF;
		}
	}
}

void Engine::SetRegisteredParamMSB(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartData* const partData = &mPartData[partNo];

		partData->mRegParamMSB = value;
		const int lsb = partData->mRegParamLSB;

		if (RPN(value, lsb) == RPN(0x7F, 0x7F))
		{
			partData->mRegParamMSB = 0xFF;
			partData->mRegParamLSB = 0xFF;
		}
	}
}

void Engine::SetDataEntryMSB(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	EParamChange param = kParamChangeNone;
	int data;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartData* const partData = &mPartData[partNo];
		const int rpn = RPN(partData->mRegParamMSB, partData->mRegParamLSB);

		MultiPart* const multiPart = &mMultiPart[partNo];

		switch (rpn)
		{
			case RPN(0x00, 0x00):
			{
				const int range = wdl_min(value, 24);
				multiPart->SetPitchBendRange(range);

				if (param != kParamChangeNone) break;

				param = kParamChannelPitchBendRange;
				data = range;
				break;
			}

			case RPN(0x00, 0x01):
			{
				partData->mFineTuneMSB = value;

				const int lsb = partData->mFineTuneLSB;
				partData->mFineTuneLSB = 0;

				const int detune = GetDetune(value, lsb);

				if (multiPart->GetDetune() != detune)
				{
					multiPart->SetDetune(detune);
					UpdateDetune(partNo, detune);
				}

				if (param != kParamChangeNone) break;

				param = kParamChannelDetune;
				data = detune;
				break;
			}

			case RPN(0x00, 0x02):
			{
				const int shift = Clamp(value, 40, 88);
				multiPart->SetNoteShift(shift);

				if (param != kParamChangeNone) break;

				param = kParamChannelNoteShift;
				data = shift;
				break;
			}
		}
	}

	param = paramChange ? param : kParamChangeNone;
	if (param == kParamChangeNone) return;

	SetParamChange(param, midiCh);

	mParamChange[2] = data;
	mParamChange[3] = value;
}

void Engine::SetDataEntryLSB(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	EParamChange param = kParamChangeNone;
	int data;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartData* const partData = &mPartData[partNo];
		const int rpn = RPN(partData->mRegParamMSB, partData->mRegParamLSB);

		if (rpn == RPN(0x00, 0x01))
		{
			const int msb = partData->mFineTuneMSB;
			partData->mFineTuneLSB = value;

			if (msb & 0x80) continue;

			MultiPart* const multiPart = &mMultiPart[partNo];
			const int detune = GetDetune(msb, value);

			/* if (multiPart->GetDetune() != detune)
			{ */
				multiPart->SetDetune(detune); /*
				UpdateDetune(partNo, detune);
			} */

			if (param != kParamChangeNone) continue;

			param = kParamChannelDetune;
			data = detune;
		}
	}

	param = paramChange ? param : kParamChangeNone;
	if (param == kParamChangeNone) return;

	SetParamChange(param, midiCh);

	mParamChange[2] = data;
	mParamChange[3] = value;
}

#undef RPN

int Engine::GetDetune(const int msb, const int lsb)
{
	assert(msb >= 0 && msb <= 127);
	assert(lsb >= 0 && lsb <= 127);

	const int y1 = (unsigned int)(abs(((msb << 7) | lsb) - 8192) * 100) >> 13;
	const int y2 = -y1;

	return (msb & 64 ? y1 : y2) + 128;
}

void Engine::UpdateDetune(const int partNo, int detune)
{
	assert(partNo >= 0 && partNo < kNumParts);
	assert(detune >= 28 && detune <= 228);

	detune += mSystem.GetMasterTune() - 2*128;

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		WaveGen* const waveGen = &mWaveGen[i];
		if (!waveGen->IsActive()) continue;

		WaveData* const waveData = &mWaveData[i];
		if (waveData->GetPartNo() != partNo) continue;

		waveData->mDetune = detune;
		UpdatePitch(waveGen, waveData);
	}
}

void Engine::AllSoundOff(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if (value != 0) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		PartSoundOff(partNo);
	}
}

void Engine::PartSoundOff(const int partNo)
{
	assert(partNo >= 0 && partNo < kNumParts);

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		WaveData* const waveData = &mWaveData[i];
		if (waveData->GetPartNo() != partNo) continue;

		FastRelease(&mWaveGen[i]);

		mNoteOnCounter[i] = 0;
		waveData->mNote = 0x80;
	}
}

// TN: Same as code below, but presumably less efficient.

/* void Engine::ResetAllControllers(const int midiCh, int const value)
{
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if (value != 0) return;

	PitchBend(midiCh, 0);
	ChannelAftertouch(midiCh, 0);
	SetModWheel(midiCh, 0);
	SetExpression(midiCh, 127);
	SetPortamento(midiCh, 0);
	SetRegisteredParamLSB(midiCh, 127);
	SetRegisteredParamMSB(midiCh, 127);
	SetHold1(midiCh, 0);
} */

void Engine::ResetAllControllers(const int midiCh, int const value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if (value != 0) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		PartData* const partData = &mPartData[partNo];
		static const int expr = 127;

		partData->mFlags = 0;
		partData->mModWheel = 0;
		partData->mAftertouch = 0;
		partData->mExpression = expr;
		partData->mPitchBend = 0;
		partData->mRegParamMSB = 0xFF;
		partData->mRegParamLSB = 0xFF;

		const int vol = mMultiPart[partNo].GetVolume();

		for (int i = 0; i < kMaxNumPoly; ++i)
		{
			WaveGen* const waveGen = &mWaveGen[i];
			if (!waveGen->IsActive()) continue;

			WaveData* const waveData = &mWaveData[i];
			if (waveData->GetPartNo() != partNo) continue;

			if (waveData->mPartNo & kFlagHold1)
			{
				waveData->mPartNo ^= kFlagHold1;
				assert(partNo != kPartDrums);

				waveGen->KeyOff(mSamplePeriod);

				mNoteOnCounter[i] = 0;
				waveData->mNote = 0x80;
			}

			if (partNo != kPartDrums)
			{
				waveData->mPitchBend = 0;
				waveData->mCAFPitch = 0;

				if (!(waveData->mLFOFlags & kFlagLFODelay))
				{
					UpdatePitchMod(waveGen, waveData);
				}

				UpdatePitch(waveGen, waveData);
			}

			const int level = GetTotalLevel(waveData->mElemLevel, waveData->mVeloLevel, expr, vol);
			waveData->mTotalLevel = level;

			waveGen->SetTotalLevel(level, true);
		}
	}
}

void Engine::AllNotesOff(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if (value != 0) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		const int hold = mPartData[partNo].mFlags & kFlagHold1;
		int n = 0;

		for (int i = 0; i < kMaxNumPoly; ++i)
		{
			WaveData* const waveData = &mWaveData[i];
			if (waveData->GetPartNo(kFlagHold1) != partNo) continue;

			if (hold)
			{
				waveData->mPartNo |= kFlagHold1;
				continue;
			}

			mWaveGen[i].KeyOff(mSamplePeriod);

			mNoteOnCounter[i] = 0;
			waveData->mNote = 0x80;

			n++;
		}

		if (!n) continue;

		MonoData* const monoData = &mMonoData[partNo];

		monoData->mNumNotes = 0;
		memset(monoData->mAlloc, 0xFF, 2);
	}
}

void Engine::MonoModeOn(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if ((unsigned int)value > (unsigned int)kNumMidiChannels) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];
	bool change = false;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartSoundOff(partNo);
		MonoData* const monoData = &mMonoData[partNo];

		monoData->mNumNotes = 0;
		memset(monoData->mAlloc, 0xFF, 2);

		mMultiPart[partNo].SetPolyMode(false);
		change = paramChange;
	}

	if (!change) return;

	SetParamChange(kParamChannelPolyMode, midiCh);

	mParamChange[2] = false;
	mParamChange[3] = value;
}

void Engine::PolyModeOn(const int midiCh, const int value, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	if (value != 0) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];
	bool change = false;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		PartSoundOff(partNo);
		/* MonoData* const monoData = &mMonoData[partNo];

		monoData->mNumMono = 0;
		memset(monoData->mMonoAlloc, 0xFF, 2); */

		mMultiPart[partNo].SetPolyMode(true);
		change = paramChange;
	}

	if (!change) return;

	SetParamChange(kParamChannelPolyMode, midiCh);

	mParamChange[2] = true;
	mParamChange[3] = /* value */ 0;
}

void Engine::ProgramChange(const int midiCh, const int prog, const bool paramChange)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(prog >= 0 && prog <= 127);

	if (!mSystem.IsEnabled(kEnableProgramChange)) return;

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	const char* name = NULL;
	int bank;

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		mMultiPart[partNo].SetProgram(prog);
		name = LoadProgram(partNo, prog, &bank);
	}

	name = paramChange ? name : NULL;
	if (!name) return;

	static const int mode = kModeGeneralMidi;
	SetParamChange(kParamProgramChange, mode);

	mParamChange[2] = midiCh;
	mParamChange[3] = bank;
	mParamChange[4] = prog;

	memcpy(&mParamChange[8], name, 8);
}

const char* Engine::LoadProgram(const int partNo, const int prog, int* const pBank)
{
	assert(partNo >= 0 && partNo < kNumParts);
	assert(prog >= 0 && prog <= 127);

	PartData* const partData = &mPartData[(unsigned int)partNo];
	MultiPart* const multiPart = &mMultiPart[(unsigned int)partNo];

	const char* name = NULL;
	int bank;

	if (partNo != kPartDrums)
	{
		const int voiceBank = multiPart->GetVoiceBank();
		bank = mFirmware.GetVoiceBankTbl()->GetVoiceBankIdx(voiceBank);

		const int ofs = partNo >= 10;
		bank += bank == kVoiceBankCM64Parts1To9 ? ofs : 0;

		const int voiceIdx = mFirmware.GetVoiceBank(bank)->GetVoiceIdx(prog);
		const VoiceCommon* voice;

		if (voiceIdx < kNumVoices)
		{
			if (bank != kVoiceBankInternal)
			{
				voice = mFirmware.GetVoice(voiceIdx);
			}
			else
			{
				assert(voiceIdx >= 0 && voiceIdx < kNumInternalVoices);
				voice = &mVoiceMem[voiceIdx & 63];
			}

			if (!IsActivePart(partNo))
			{
				partData->mPortaTime = voice->GetPortamentoTime();
			}

			partData->mVoice = voice;
			partData->mVoiceIdx = voiceIdx;

			partData->mVoiceBank[0] = voiceBank;
			partData->mVoiceBank[1] = prog;

			multiPart->SetProgram(prog);
			name = voice->GetName();
		}
	}
	else
	{
		bank = kVoiceBankDrums;

		const int drumKitIdx = mFirmware.GetDrumBank()->GetDrumKitIdx(prog);
		const DrumKit* drumKit;

		if (drumKitIdx > kDrumKitNone)
		{
			drumKit = mFirmware.GetDrumKit(drumKitIdx);
			LoadDrumKit(drumKitIdx, drumKit);

			partData->mDrumKit = drumKit;
			// partData->mVoiceIdx = drumKitIdx;

			partData->mVoiceBank[1] = prog;

			multiPart->SetProgram(prog);
			name = mFirmware.LookupDrumKitName(drumKitIdx, prog);
		}
	}

	if (pBank) *pBank = bank;
	return name;
}

bool Engine::IsActivePart(const int partNo) const
{
	bool active = false;

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		const WaveData* const waveData = &mWaveData[i];

		int j = waveData->GetPartNo();
		const int noteOff = waveData->mNote & 0x80;

		j = j == kPartDrums ? partNo : j;

		if (j == partNo && !noteOff)
		{
			active = true;
			break;
		}
	}

	return active;
}

void Engine::LoadDrumKit(int drumKitIdx, const DrumKit* const drumKit)
{
	assert(drumKitIdx >= 0 && drumKitIdx < kNumDrumKits);

	drumKitIdx -= kDrumKitBrush;
	drumKitIdx = (unsigned int)drumKitIdx < (unsigned int)kNumAltGroupTables ? drumKitIdx : kDrumKitStandard;

	const unsigned char* const tbl = mAltGroupTbl[(unsigned int)drumKitIdx];

	for (int i = 0; i < kNumDrumNotes; ++i)
	{
		const int note = i + kDrumNoteMin;
		int soundIdx = drumKit->GetDrumSoundIdx(note);

		int pan = 0, reverb = 0;

		if (soundIdx < kDrumSoundOff)
		{
			const DrumSound* const drumSound = mFirmware.GetDrumSound(soundIdx);

			pan = drumSound->GetPan();
			reverb = drumSound->GetReverbDepth();

			int altNote = tbl[i];
			altNote = !altNote ? note : altNote;

			if (altNote < note)
			{
				assert(altNote >= kDrumNoteMin && altNote <= kDrumNoteMax);
				const unsigned int inst = altNote - kDrumNoteMin;

				soundIdx = mAltGroup[inst];
			}
		}

		DrumSetup* const drumSetup = &mDrumSetup[i];

		drumSetup->SetPan(pan);
		drumSetup->SetReverbDepth(reverb);

		mAltGroup[i] = soundIdx;
	}
}

void Engine::ChannelAftertouch(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= 0 && value <= 127);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		mPartData[partNo].mAftertouch = value;

		const int control = mMultiPart[partNo].GetAftertouchPitchControl();
		const int pitch = GetAftertouchPitch(value, control);

		for (int i = 0; i < kMaxNumPoly; ++i)
		{
			WaveGen* const waveGen = &mWaveGen[i];
			if (!waveGen->IsActive()) continue;

			WaveData* const waveData = &mWaveData[i];
			if (waveData->GetPartNo() != partNo) continue;

			waveData->mCAFPitch = pitch;
			UpdatePitch(waveGen, waveData);
		}

		UpdatePitchModDepth(partNo);
	}
}

int Engine::GetAftertouchPitch(const int caf, const int control)
{
	assert(caf >= 0 && caf <= 127);
	assert(control >= 40 && control <= 88);

	return ((!!caf + caf) * ((control - 64) * 25)) >> 5;
}

void Engine::PitchBend(const int midiCh, const int value)
{
	assert(GetStatus() == true);
	assert(midiCh >= 0 && midiCh < kNumMidiChannels);
	assert(value >= -8192 && value < +8192);

	const unsigned char* partList = mPartList[(unsigned int)midiCh];

	for (;;)
	{
		const int partNo = *partList++;
		if (partNo & 0x80) break;

		if (partNo == kPartDrums) continue;

		mPartData[partNo].mPitchBend = value;

		const int range = mMultiPart[partNo].GetPitchBendRange();
		const int pitch = GetPitchBend(value, range);

		for (int i = 0; i < kMaxNumPoly; ++i)
		{
			WaveGen* const waveGen = &mWaveGen[i];
			if (!waveGen->IsActive()) continue;

			WaveData* const waveData = &mWaveData[i];
			if (waveData->GetPartNo() != partNo) continue;

			waveData->mPitchBend = pitch;
			UpdatePitch(waveGen, waveData);
		}
	}
}

int Engine::GetPitchBend(const int pitchBend, const int range)
{
	assert(pitchBend >= -8192 && pitchBend < +8192);
	assert(range >= 0 && range <= 24);

	return (((pitchBend > 0) + pitchBend) * (range * 25)) >> 11;
}

bool Engine::ProcessSysEx(const void* const buf, const int size)
{
	assert(GetStatus() == true);

	const unsigned char* const ptr = (unsigned const char*)buf;

	int state = mSysExState, err = 0;

	for (int i = 0; i < size; ++i)
	{
		state = ParseSysExByte(state, ptr[i]);
		err |= state;
	}

	mSysExState = state;

	err &= kSysExIllegalData;

	return !err;
}

int Engine::ParseSysExByte(int state, const int byte)
{
	state &= ~kSysExIllegalData;
	assert(byte == (unsigned char)byte);

	switch ((unsigned int)state)
	{
		// F0 [... F7]
		case kSysExStatus:
		{
			if (byte != 0xF0) break;
			state++;
			break;
		}

		// [F0] 43 [... F7]
		// [F0] 7E [nn 09 01 F7]
		// [F0] 7F [nn 04 01 ll mm F7]
		case kSysExMfrID:
		{
			switch (byte)
			{
				case 0x43: state = kSysExParamChange; break;
				case 0x7E: state = kSysExNonRealTime; break;
				case 0x7F: state = kSysExRealTime; break;
				default: state = kSysExStatus; break;
			}
			break;
		}

		// [F0 7E] xn [09 01 F7]
		// [F0 7F] xn [04 01 ll mm F7]
		case kSysExNonRealTime:
		case kSysExRealTime:
		{
			state++;
			if (byte == 0x7F) break;

			if (!(byte & 0x80))
			{
				const int devNo = mSystem.GetDeviceNo();
				if (devNo == kDeviceNoAll || (byte & 15) == devNo) break;
			}

			state = kSysExStatus;
			break;
		}

		// [F0 7E xn] 09 [01 F7]
		case kSysExGeneralMidi:
		{
			state++;
			state = byte == 0x09 ? state : kSysExStatus;
			break;
		}

		// [F0 7E xn 09] 01 [F7]
		case kSysExGMModeOn:
		{
			if (byte == 0x01) GeneralMidiModeOn(true);
			state = kSysExStatus;
			break;
		}

		// [F0 7F xn] 04 01 [ll mm F7]
		case kSysExDeviceControl:
		case kSysExMasterVolume:
		{
			const int subID = state++ == kSysExDeviceControl ? 0x04 : 0x01;
			state = byte == subID ? state : kSysExStatus;
			break;
		}

		// [F0 7F xn 04 01] ll [mm F7]
		case kSysExVolumeLSB:
		{
			state++;
			state = !(byte & 0x80) ? state : kSysExStatus;
			break;
		}

		// [F0 7F xn 04 01 11] mm [F7]
		case kSysExVolumeMSB:
		{
			if (!(byte & 0x80))
			{
				SetMasterVolume(byte);
				SetParamChange(kParamMasterVolume, byte);
			}

			state = kSysExStatus;
			break;
		}

		// [F0 43] 1n [27 aa aa aa dd ... cc F7]
		// [F0 43] 73 [01 14 F7]
		case kSysExParamChange:
		{
			state++;

			if ((byte & 0xF0) == 0x10)
			{
				const int devNo = mSystem.GetDeviceNo();
				if (devNo == kDeviceNoAll || (byte & 15) == devNo) break;
			}
			else if (byte == 0x73)
			{
				state = kSysExClaviModelID;
				break;
			}

			state = kSysExStatus;
			break;
		}

		// [F0 43 1n] 27 [aa aa aa dd ... cc F7]
		case kSysExModelID:
		{
			state++;
			state = byte == 0x27 ? state : kSysExStatus;

			mSysExData[0] = mSysExData[1] = 0xFF;
			mSysExChecksum = 0;
			mSysExAddr = 0;
			break;
		}

		// [F0 43 1n 27] aa aa aa [dd ... cc F7]
		case kSysExAddrHigh:
		case kSysExAddrMid:
		case kSysExAddrLow:
		{
			state++;

			if (!(byte & 0x80))
			{
				mSysExChecksum += byte;
				mSysExAddr = (mSysExAddr << 7) | byte;
				break;
			}

			state = kSysExStatus;
			break;
		}

		// [F0 43 1n 27 aa aa aa] dd ... cc [F7]
		case kSysExData:
		case kSysExAllParamsReset:
		{
			if (!(byte & 0x80))
			{
				const int data = mSysExData[0];

				if (!(data & 0x80))
				{
					state = ParseSysExData(state, mSysExAddr++, data);
				}

				mSysExData[0] = byte;
				mSysExChecksum += byte;
				break;
			}

			const bool reset = state == kSysExAllParamsReset;
			state = kSysExStatus;

			if (byte != 0xF7) break;

			if ((mSysExChecksum & 0x7F) != 0)
				state |= kSysExIllegalData;
			else if (reset)
				AllParametersReset(true);
			break;
		}

		// [F0 43 73] 01 [14 F7]
		case kSysExClaviModelID:
		{
			state++;
			state = byte == 0x01 ? state : kSysExStatus;
			break;
		}

		// [F0 43 73 01] 14 [F7]
		case kSysExDiskMusicOn:
		{
			if (byte == 0x14)
			{
				#ifndef NDEBUG
				SetParamChange(kParamDiskMusicOn, 0xFF);
				#else
				mParamChange[0] = kParamDiskMusicOn;
				#endif
			}

			state = kSysExStatus;
			break;
		}

		default:
		{
			state = kSysExStatus;
			break;
		}
	}

	return state;
}

void Engine::GeneralMidiModeOn(const bool paramChange)
{
	assert(GetStatus() == true);

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		FastRelease(&mWaveGen[i]);
	}

	ResetWaveData();
	ResetPartData(paramChange);

	mSystem.Reset();
	mMultiCommon.Reset();

	ResetMultiPart();

	LoadDefaultPrograms(paramChange);
	SetReverbType(mMultiCommon.GetReverbType());
}

void Engine::ResetWaveData()
{
	mPitchModIdx = 0;

	memset(mNoteOnCounter, 0, sizeof(mNoteOnCounter));

	mNumNoteOffCounters = 0;
	memset(mNoteOffCounter, 0, sizeof(mNoteOffCounter));

	memset(mWaveData, 0, sizeof(mWaveData));

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		WaveData* const waveData = &mWaveData[i];

		waveData->mNote = 0xFF;
		waveData->mAltGroup = 0xFFFF;
	}
}

void Engine::ResetPartData(const bool paramChange)
{
	for (int i = 0; i < kNumParts; ++i)
	{
		PartData* const partData = &mPartData[i];
		memset(partData, 0, sizeof(PartData));

		partData->mExpression = 127;
		partData->mRegParamMSB = 0xFF;
		partData->mRegParamLSB = 0xFF;
		partData->mFineTuneMSB = 0xFF;
		partData->mPortaNote = kNoteMiddleC;
		partData->mVoiceBank[0] = 56;
	}

	for (int i = 0; i < kNumParts; ++i)
	{
		MonoData* const monoData = &mMonoData[i];

		monoData->mNumNotes = 0;
		monoData->mVoiceIdx = 0xFF;
		memset(monoData->mAlloc, 0xFF, 2);
	}

	for (int i = 0; i < kNumMidiChannels; ++i)
	{
		unsigned char* const partList = mPartList[i];
		const int partNo = mPartNoTbl[i];

		partList[0] = partNo;
		partList[1] = 0xFF;
	}

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		mAllocList[i] = i;
	}

	if (paramChange) mParamChange[7] |= kParamFlagPartMidiChannel;
}

void Engine::ResetMultiPart()
{
	for (int i = 0; i < kNumParts; ++i)
	{
		MultiPart* const multiPart = &mMultiPart[i];
		const int midiCh = mMidiChannelTbl[i];

		multiPart->Init();
		multiPart->SetMidiChannel(midiCh);
	}
}

void Engine::ResetVoiceMemory()
{
	const VoiceCommon* const presetVoices = mFirmware.GetVoice(0);
	memcpy(mVoiceMem, presetVoices, kNumInternalVoices * sizeof(VoiceCommon));
}

void Engine::LoadDefaultPrograms(const bool paramChange)
{
	for (int i = 0; i < kNumDrumNotes; i += 2)
	{
		DrumSetup* const drumSetup = &mDrumSetup[i];

		drumSetup[0].Init();
		drumSetup[1].Init();
	}

	if (kNumDrumNotes & 1) mDrumSetup[kNumDrumNotes - 1].Init();

	memset(mAltGroup, 0xFF, sizeof(mAltGroup));
	mSysExState = kSysExStatus;

	static const int drumKitIdx = kDrumKitStandard;
	const DrumKit* const drumKit = mFirmware.GetDrumKit(drumKitIdx);

	mPartData[kPartDrums].mDrumKit = drumKit;
	// mPartData[kPartDrums].mVoiceIdx = drumKitIdx;

	assert(drumKitIdx == kDrumKitStandard);
	mPartData[kPartDrums].mVoiceBank[1] = 0;

	static const int bank = kVoiceBankGeneralMidi, prog = kProgramGrandPno;
	const int voiceIdx = mFirmware.GetVoiceBank(bank)->GetVoiceIdx(prog);

	const VoiceCommon* const defaultVoice = mFirmware.GetVoice(voiceIdx);

	for (int i = 1; i < kNumParts; ++i)
	{
		PartData* const partData = &mPartData[i];

		partData->mVoice = defaultVoice;
		partData->mVoiceIdx = voiceIdx;

		partData->mVoiceBank[0] = 56;
		partData->mVoiceBank[1] = prog;
	}

	LoadDrumKit(drumKitIdx, drumKit);

	if (!paramChange) return;

	static const int mode = kModeGeneralMidi, midiCh = 0;
	SetParamChange(kParamGeneralMidiModeOn, mode);

	mParamChange[2] = midiCh;
	mParamChange[3] = bank;
	mParamChange[4] = prog;

	memcpy(&mParamChange[8], defaultVoice->GetName(), 8);
}

void Engine::AllParametersReset(const bool paramChange)
{
	assert(GetStatus() == true);

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		FastRelease(&mWaveGen[i]);
	}

	ResetWaveData();
	ResetPartData(paramChange);

	mSystem.Init();
	mMultiCommon.Init();

	ResetMultiPart();
	ResetVoiceMemory();

	LoadDefaultPrograms(paramChange);
	SetReverbType(mMultiCommon.GetReverbType());
}

#define ADDR(high, mid, low) (((high) << 14) | ((mid) << 7) | (low))

int Engine::ParseSysExData(int state, int addr, const int data)
{
	if (addr < ADDR(0x30, 0x03, 0x10))
	{
		if (addr < ADDR(0x30, 0x00, 0x10))
		{
			ParseSystemData(addr, data);
		}
		else
		{
			static const unsigned int denom = sizeof(MultiPart);
			addr -= ADDR(0x30, 0x00, 0x10);

			const int partNo = (unsigned int)addr / denom;
			addr = (unsigned int)addr % denom;

			ParseMultiPartData(addr, partNo, data);
		}
	}
	else
	{
		if (addr < ADDR(0x30, 0x33, 0x10))
		{
			static const unsigned int denom = sizeof(VoiceCommon);
			addr -= ADDR(0x30, 0x03, 0x10);

			const int prog = (unsigned int)addr / denom;
			addr = (unsigned int)addr % denom;

			ParseVoiceMemoryData(addr, prog, data);
		}
		else if (addr < ADDR(0x30, 0x35, 0x06))
		{
			static const unsigned int denom = sizeof(DrumSetup);
			addr -= ADDR(0x30, 0x33, 0x10);

			const int inst = (unsigned int)addr / denom;
			addr = (unsigned int)addr % denom;

			ParseDrumSetupData(addr, inst + kDrumNoteMin, data);

		}
		else if (addr == ADDR(0x30, 0x35, 0x06))
		{
			state = kSysExAllParamsReset;
		}
	}

	return state;
}

void Engine::ParseSystemData(const int addr, const int data)
{
	assert(data >= 0 && data <= 127);

	switch ((unsigned int)addr)
	{
		case ADDR(0x30, 0x00, 0x00):
		{
			mSysExData[1] = data;
			break;
		}

		case ADDR(0x30, 0x00, 0x01):
		{
			int byte = mSysExData[1];
			mSysExData[1] = 0xFF;

			if (byte & 0x80) break;
			byte = (unsigned char)(byte << 4) | (data & 0x0F);

			const int detune = Clamp(byte, 28, 228);
			SetMasterTune(detune);

			SetParamChange(kParamMasterTune, detune);
			break;
		}

		case ADDR(0x30, 0x00, 0x02):
		{
			const int shift = Clamp(data, 40, 88);
			mSystem.SetTranspose(shift);

			SetParamChange(kParamTranspose, shift);
			break;
		}

		case ADDR(0x30, 0x00, 0x03):
		{
			const int devNo = wdl_min(data, kDeviceNoAll);

			mSystem.SetDeviceNo(devNo);
			const bool sysEx = mSystem.IsEnabled(kEnableSysEx);

			SetParamChange(kParamDeviceNo, sysEx);
			mParamChange[2] = devNo;
			break;
		}

		case ADDR(0x30, 0x00, 0x04):
		{
			const bool sysEx = wdl_min(data, 1);

			const int devNo = mSystem.GetDeviceNo();
			/* mSystem.SetEnable(kEnableSysEx, sysEx); */

			SetParamChange(kParamEnableSysEx, sysEx);
			mParamChange[2] = devNo;
			break;
		}

		case ADDR(0x30, 0x00, 0x05):
		{
			const bool pc = wdl_min(data, 1);

			mSystem.SetEnable(kEnableProgramChange, pc);
			const bool cc = mSystem.IsEnabled(kEnableControlChange);

			SetParamChange(kParamEnableProgramChange, pc);
			mParamChange[2] = cc;
			break;
		}

		case ADDR(0x30, 0x00, 0x06):
		{
			const bool cc = wdl_min(data, 1);

			const bool pc = mSystem.IsEnabled(kEnableProgramChange);
			mSystem.SetEnable(kEnableControlChange, cc);

			SetParamChange(kParamEnableControlChange, pc);
			mParamChange[2] = cc;
			break;
		}

		case ADDR(0x30, 0x00, 0x07):
		{
			const int mode = wdl_min(data, kModeCM64);
			/* mSystem.SetSoundModuleMode(mode); */

			if (mode == kModeGeneralMidi)
			{
				GeneralMidiModeOn(true);
				mParamChange[0] = kParamSoundModuleMode;
			}
			else
			{
				SetParamChange(kParamSoundModuleMode, mode);
			}
			break;
		}

		case ADDR(0x30, 0x00, 0x08):
		{
			SetMasterVolume(data);
			SetParamChange(kParamMasterVolume, data);
			break;
		}

		case ADDR(0x30, 0x00, 0x09):
		{
			const EVelocityMeter meter = wdl_min(data, kVelocityMeterOn);
			mSystem.SetVelocityMeter(meter);

			SetParamChange(kParamVelocityMeter, meter);
			break;
		}

		case ADDR(0x30, 0x00, 0x0A):
		{
			const EReverbType type = wdl_min(data, kReverbDelay2);
			SetReverbType(type);

			SetParamChange(kParamReverbType, type);
			break;
		}

		case ADDR(0x30, 0x00, 0x0B):
		{
			const int time = Clamp(data, 3, 54);
			mMultiCommon.SetReverbTime(time);

			SetParamChange(kParamReverbTime, time);
			break;
		}

		case ADDR(0x30, 0x00, 0x0C):
		{
			const int level = Clamp(data, 24, 70);
			mMultiCommon.SetReverbOutputLevel(level);

			SetParamChange(kParamReverbOutputLevel, level);
			break;
		}
	}
}

#undef ADDR

void Engine::SetMasterTune(int detune)
{
	assert(GetStatus() == true);

	if (mSystem.GetMasterTune() != detune)
	{
		mSystem.SetMasterTune(detune);

		detune -= 2*128;

		for (int i = 0; i < kMaxNumPoly; ++i)
		{
			WaveGen* const waveGen = &mWaveGen[i];
			if (!waveGen->IsActive()) continue;

			WaveData* const waveData = &mWaveData[i];
			const int partNo = waveData->GetPartNo();
			if (partNo == kPartDrums) continue;

			waveData->mDetune = mMultiPart[partNo].GetDetune() + detune;
			UpdatePitch(waveGen, waveData);
		}
	}
}

void Engine::SetSoundModuleMode(const ESoundModuleMode mode)
{
	assert(GetStatus() == true);

	/* mSystem.SetSoundModuleMode(mode); */
	if (mode == kModeGeneralMidi) GeneralMidiModeOn();
}

void Engine::SetMasterVolume(const int vol)
{
	assert(GetStatus() == true);

	if (mSystem.GetMasterVolume() != vol)
	{
		mSystem.SetMasterVolume(vol);

		for (int i = 0; i < kMaxNumPoly; ++i)
		{
			WaveGen* const waveGen = &mWaveGen[i];
			if (!waveGen->IsActive()) continue;

			WaveData* const waveData = &mWaveData[i];
			const int partNo = waveData->GetPartNo();

			int level = waveData->mElemLevel;
			const int velo = waveData->mVeloLevel;

			const int expr = mPartData[partNo].mExpression;
			const int cc7 = mMultiPart[partNo].GetVolume();

			level = GetTotalLevel(level, velo, expr, cc7);
			waveData->mTotalLevel = level;

			waveGen->SetTotalLevel(level, true);
		}
	}
}

void Engine::SetReverbType(const EReverbType type)
{
	const int level = MultiCommon::GetReverbOutputLevel(type);

	mMultiCommon.SetReverbType(type);
	mMultiCommon.SetReverbOutputLevel(level);
}

#define ADDR(mid, low) (((mid) << 7) | (low))

void Engine::ParseMultiPartData(const int addr, const int partNo, const int data)
{
	assert(data >= 0 && data <= 127);

	MultiPart* const multiPart = GetMultiPart(partNo);

	switch ((unsigned int)addr)
	{
		case ADDR(0x00, 0x00):
		{
			mSysExData[1] = data;
			multiPart->SetVoiceBank(data);
			break;
		}

		case ADDR(0x00, 0x01):
		{
			int bank = mSysExData[1];
			mSysExData[1] = 0xFF;

			if (bank & 0x80) break;

			multiPart->SetProgram(data);

			const char* const name = LoadProgram(partNo, data, &bank);
			if (!name) break;

			static const int mode = kModeGeneralMidi;
			SetParamChange(kParamPartProgram, mode);

			mParamChange[2] = partNo;
			mParamChange[3] = bank;
			mParamChange[4] = data;

			memcpy(&mParamChange[8], name, 8);
			break;
		}

		case ADDR(0x00, 0x02):
		{
			const int midiCh = wdl_min(data, kMidiChannelOff);
			SetPartMidiChannel(partNo, midiCh);

			SetParamChange(kParamPartMidiChannel, partNo);

			mParamChange[2] = midiCh;
			mParamChange[7] |= kParamFlagPartMidiChannel;
			break;
		}

		case ADDR(0x00, 0x03):
		{
			const bool mode = wdl_min(data, 1);
			SetPartPolyMode(partNo, mode);

			SetParamChange(kParamPartPolyMode, partNo);
			mParamChange[2] = mode;
			break;
		}

		case ADDR(0x00, 0x04):
		{
			mSysExData[1] = data;
			break;
		}

		case ADDR(0x00, 0x05):
		{
			int byte = mSysExData[1];
			mSysExData[1] = 0xFF;

			if (byte & 0x80) break;
			byte = (unsigned char)(byte << 4) | (data & 0x0F);

			const int detune = Clamp(byte, 28, 228);
			SetPartDetune(partNo, detune);

			SetParamChange(kParamPartDetune, partNo);
			mParamChange[2] = detune;
			break;
		}

		case ADDR(0x00, 0x06):
		{
			const int shift = Clamp(data, 40, 88);
			multiPart->SetNoteShift(shift);

			SetParamChange(kParamPartNoteShift, partNo);
			mParamChange[2] = shift;
			break;
		}

		case ADDR(0x00, 0x07):
		{
			SetPartVolume(partNo, data);

			SetParamChange(kParamPartVolume, partNo);
			mParamChange[2] = data;
			break;
		}

		case ADDR(0x00, 0x08):
		{
			const int sense = wdl_min(data, 15);
			multiPart->SetVelocitySense(sense);

			SetParamChange(kParamPartVelocitySense, partNo);
			mParamChange[2] = sense;
			break;
		}

		case ADDR(0x00, 0x09):
		{
			const int pan = wdl_min(data, 15);
			SetPartPan(partNo, pan);

			SetParamChange(kParamPartPan, partNo);
			mParamChange[2] = pan;
			break;
		}

		case ADDR(0x00, 0x0A):
		{
			multiPart->SetNoteLimitLow(data);

			SetParamChange(kParamPartNoteLimitLow, partNo);
			mParamChange[2] = data;
			break;
		}

		case ADDR(0x00, 0x0B):
		{
			multiPart->SetNoteLimitHigh(data);

			SetParamChange(kParamPartNoteLimitHigh, partNo);
			mParamChange[2] = data;
			break;
		}

		case ADDR(0x00, 0x0C):
		{
			const int depth = wdl_min(data, 8);
			multiPart->SetReverbSendDepth(depth);

			SetParamChange(kParamPartReverbDepth, partNo);
			mParamChange[2] = depth;
			break;
		}

		case ADDR(0x00, 0x0D):
		{
			const int speed = Clamp(data, 57, 71);
			multiPart->SetLFOSpeed(speed);

			SetParamChange(kParamPartLFOSpeed, partNo);
			mParamChange[2] = speed;
			break;
		}

		case ADDR(0x00, 0x0E):
		{
			const int depth = Clamp(data, 49, 79);
			multiPart->SetLFODepth(depth);

			SetParamChange(kParamPartLFODepth, partNo);
			mParamChange[2] = depth;
			break;
		}

		case ADDR(0x00, 0x0F):
		{
			multiPart->SetLFODelay(data);

			SetParamChange(kParamPartLFODelay, partNo);
			mParamChange[2] = data;
			break;
		}

		case ADDR(0x00, 0x10):
		{
			const int rate = Clamp(data, 57, 71);
			multiPart->SetEGAttackRate(rate);

			SetParamChange(kParamPartEGAttackRate, partNo);
			mParamChange[2] = rate;
			break;
		}

		case ADDR(0x00, 0x11):
		{
			const int rate = Clamp(data, 57, 71);
			multiPart->SetEGReleaseRate(rate);

			SetParamChange(kParamPartEGReleaseRate, partNo);
			mParamChange[2] = rate;
			break;
		}

		case ADDR(0x00, 0x12):
		{
			const int range = wdl_min(data, 24);
			multiPart->SetPitchBendRange(range);

			SetParamChange(kParamPartPitchBendRange, partNo);
			mParamChange[2] = range;
			break;
		}

		case ADDR(0x00, 0x13):
		{
			const int depth = wdl_min(data, 15);
			multiPart->SetModLFOPitchDepth(depth);

			SetParamChange(kParamPartModLFOPitchDepth, partNo);
			mParamChange[2] = depth;
			break;
		}

		case ADDR(0x00, 0x15):
		{
			const int control = Clamp(data, 40, 88);
			multiPart->SetAftertouchPitchControl(control);

			SetParamChange(kParamPartAftertouchPitchControl, partNo);
			mParamChange[2] = control;
			break;
		}

		case ADDR(0x00, 0x16):
		{
			const int depth = wdl_min(data, 15);
			multiPart->SetAftertouchLFOPitchDepth(depth);

			SetParamChange(kParamPartAftertouchLFOPitchDepth, partNo);
			mParamChange[2] = depth;
			break;
		}
	}
}

#undef ADDR

void Engine::SetPartProgram(const int partNo, const int bank, const int prog)
{
	assert(GetStatus() == true);

	MultiPart* const multiPart = GetMultiPart(partNo);

	multiPart->SetVoiceBank(bank);
	multiPart->SetProgram(prog);

	LoadProgram(partNo, prog);
}

void Engine::SetPartMidiChannel(const int partNo, const int midiCh)
{
	assert(GetStatus() == true);

	PartSoundOff(partNo);
	MultiPart* const multiPart = GetMultiPart(partNo);

	if (multiPart->GetMidiChannel() != midiCh)
	{
		multiPart->SetMidiChannel(midiCh);
		UpdatePartList();
	}
}

void Engine::UpdatePartList()
{
	for (int i = 0; i < kNumMidiChannels; ++i)
	{
		unsigned char* partList = mPartList[i];

		for (int j = 0; j < kNumParts; ++j)
		{
			if (mMultiPart[j].GetMidiChannel() == i) *partList++ = j;
		}

		*partList = 0xFF;
	}
}

void Engine::SetPartPolyMode(const int partNo, const bool mode)
{
	assert(GetStatus() == true);
	assert(partNo >= 0 && partNo < kNumParts);

	PartSoundOff(partNo);

	if (!mode)
	{
		MonoData* const monoData = &mMonoData[(unsigned int)partNo];

		monoData->mNumNotes = 0;
		memset(monoData->mAlloc, 0xFF, 2);
	}

	GetMultiPart(partNo)->SetPolyMode(mode);
}

void Engine::SetPartDetune(const int partNo, const int detune)
{
	assert(GetStatus() == true);

	MultiPart* const multiPart = GetMultiPart(partNo);

	if (multiPart->GetDetune() != detune)
	{
		multiPart->SetDetune(detune);
		if (partNo != kPartDrums) UpdateDetune(partNo, detune);
	}
}

void Engine::SetPartVolume(const int partNo, const int vol)
{
	assert(GetStatus() == true);
	assert(partNo >= 0 && partNo < kNumParts);

	const PartData* const partData = &mPartData[(unsigned int)partNo];

	GetMultiPart(partNo)->SetVolume(vol);
	UpdateTotalLevel(partNo, partData->mExpression, vol);
}

void Engine::SetPartPan(const int partNo, const int pan)
{
	assert(GetStatus() == true);
	assert(partNo >= 0 && partNo < kNumParts);

	PartData* const partData = &mPartData[(unsigned int)partNo];

	partData->mPan = pan != kPanVoice ? pan : 0;
	GetMultiPart(partNo)->SetPan(pan);
}

#define ADDR(mid, low) (((mid) << 7) | (low))

void Engine::ParseDrumSetupData(const int addr, const int note, int data)
{
	assert(data >= 0 && data <= 127);

	EParamChange param;

	#ifndef NDEBUG
	param = kParamChangeNone;
	#endif

	switch ((unsigned int)addr)
	{
		case ADDR(0x00, 0x00):
		{
			GetDrumSetup(note)->SetLevel(data);
			param = kParamDrumLevel;
			break;
		}

		case ADDR(0x00, 0x01):
		{
			data = wdl_min(data, 15);
			GetDrumSetup(note)->SetPan(data);

			param = kParamDrumPan;
			break;
		}

		case ADDR(0x00, 0x02):
		{
			data = wdl_min(data, 8);
			GetDrumSetup(note)->SetReverbDepth(data);

			param = kParamDrumReverbDepth;
			break;
		}

		default: return;
	}

	const DrumKit* const drumKit = mPartData[kPartDrums].mDrumKit;
	const unsigned short soundIdx = drumKit->GetDrumSoundIdx(note);

	SetParamChange(param, note);

	mParamChange[2] = data;
	memcpy(&mParamChange[4], &soundIdx, 2);
}

void Engine::ParseVoiceMemoryData(int addr, const int prog, const int data)
{
	if (addr < ADDR(0x00, 0x18))
	{
		ParseVoiceCommonData(addr, prog, data);
	}
	else
	{
		static const unsigned int denom = sizeof(VoiceElement);
		addr -= ADDR(0x00, 0x18);

		const int elem = addr < denom ? kVoiceElement1 : kVoiceElement2;
		addr -= elem * denom;

		ParseVoiceElementData(addr, prog, elem, data);
	}
}

void Engine::ParseVoiceCommonData(const int addr, const int prog, const int data)
{
	assert(data >= 0 && data <= 127);

	VoiceCommon* const voice = GetVoiceCommon(prog);
	EVoiceElement elem;

	int value1, value2;
	EParamChange param;

	#ifndef NDEBUG
	param = kParamChangeNone;
	#endif

	switch ((unsigned int)addr)
	{
		case ADDR(0x00, 0x00):
		{
			const EVoiceMode mode = wdl_min(data, kVoiceModeDual);
			voice->SetVoiceMode(mode);

			SetParamChange(kParamVoiceMode, prog);
			mParamChange[2] = mode;
			return;
		}

		case ADDR(0x00, 0x01):
		case ADDR(0x00, 0x02):
		{
			elem = addr - ADDR(0x00, 0x01);
			value1 = data;

			voice->SetLevel(elem, value1);
			value2 = voice->GetLevel(1 - elem);

			param = kParamElementLevel;
			break;
		}

		case ADDR(0x00, 0x03):
		case ADDR(0x00, 0x04):
		{
			elem = addr - ADDR(0x00, 0x03);
			value1 = Clamp(data, 32, 95);

			voice->SetDetune(elem, value1);
			value2 = voice->GetDetune(1 - elem);

			param = kParamElementDetune;
			break;
		}

		case ADDR(0x00, 0x05):
		{
			voice->SetPortamentoTime(data);

			SetParamChange(kParamVoicePortamentoTime, prog);
			mParamChange[2] = data;
			return;
		}

		case ADDR(0x00, 0x06):
		{
			const int depth = wdl_min(data, 15);
			voice->SetModLFOPitchDepth(depth);

			SetParamChange(kParamVoiceModLFOPitchDepth, prog);
			mParamChange[2] = depth;
			return;
		}

		case ADDR(0x00, 0x08):
		{
			const int depth = wdl_min(data, 15);
			voice->SetAftertouchLFOPitchDepth(depth);

			SetParamChange(kParamVoiceAftertouchLFOPitchDepth, prog);
			mParamChange[2] = depth;
			return;
		}

		case ADDR(0x00, 0x0A):
		case ADDR(0x00, 0x0E):
		{
			elem = !!(addr & 4);
			value1 = wdl_min(data, kPitchRateScale0);

			voice->SetPitchRateScale(elem, value1);
			value2 = voice->GetPitchRateScale(1 - elem);

			param = kParamElementPitchRateScale;
			break;
		}

		case ADDR(0x00, 0x0B):
		case ADDR(0x00, 0x0F):
		{
			elem = !!(addr & 4);
			value1 = data;

			voice->SetPitchRateScaleCenter(elem, value1);
			value2 = voice->GetPitchRateScaleCenter(1 - elem);

			param = kParamElementPitchRateScaleCenter;
			break;
		}

		case ADDR(0x00, 0x0C):
		case ADDR(0x00, 0x0D):
		{
			elem = addr - ADDR(0x00, 0x0C);
			value1 = Clamp(data, 40, 88);

			voice->SetNoteShift(elem, value1);
			value2 = voice->GetNoteShift(1 - elem);

			param = kParamElementNoteShift;
			break;
		}

		case ADDR(0x00, 0x10):
		case ADDR(0x00, 0x11):
		case ADDR(0x00, 0x12):
		case ADDR(0x00, 0x13):
		case ADDR(0x00, 0x14):
		case ADDR(0x00, 0x15):
		case ADDR(0x00, 0x16):
		case ADDR(0x00, 0x17):
		{
			char* const name = voice->GetName();
			name[addr & 7] = wdl_max(data, ' ');

			SetParamChange(kParamVoiceName, prog);
			memcpy(&mParamChange[8], name, 8);
			return;
		}

		default: return;
	}

	SetParamChange(param, prog);

	mParamChange[2] = voice->GetVoiceMode();
	mParamChange[3] = elem;

	unsigned char* const elemChange = &mParamChange[4];

	elemChange[(unsigned int)(elem /* - kVoiceElement1 */)] = value1;
	elemChange[(unsigned int)(kVoiceElement2 - elem)] = value2;
}

void Engine::ParseVoiceElementData(const int addr, const int prog, const EVoiceElement elem, const int data)
{
	assert(data >= 0 && data <= 127);

	VoiceCommon* const voice = GetVoiceCommon(prog);

	int idx = -1, value1, value2;
	EParamChange param;

	#ifndef NDEBUG
	param = kParamChangeNone;
	#endif

	switch ((unsigned int)addr)
	{
		case ADDR(0x00, 0x00):
		case ADDR(0x00, 0x08):
		case ADDR(0x00, 0x0A):
		case ADDR(0x00, 0x0C):
		case ADDR(0x00, 0x0E):
		{
			mSysExData[1] = data;
			return;
		}

		case ADDR(0x00, 0x01):
		{
			int byte = mSysExData[1];
			mSysExData[1] = 0xFF;

			if (byte & 0x80) return;
			byte = (unsigned char)(byte << 4) | (data & 0x0F);

			static const int maxWaveNo = kNumWaveNo - 1;
			value1 = wdl_min(byte, maxWaveNo);

			voice->GetElement(elem)->SetWaveNo(value1);
			value2 = voice->GetElement(1 - elem)->GetWaveNo();

			param = kParamElementWaveNo;
			break;
		}

		case ADDR(0x00, 0x02):
		{
			value1 = Clamp(data, 49, 79);

			voice->GetElement(elem)->SetEGAttackRate(value1);
			value2 = voice->GetElement(1 - elem)->GetEGAttackRate();

			param = kParamElementEGAttackRate;
			break;
		}

		case ADDR(0x00, 0x03):
		{
			value1 = Clamp(data, 49, 79);

			voice->GetElement(elem)->SetEGReleaseRate(value1);
			value2 = voice->GetElement(1 - elem)->GetEGReleaseRate();

			param = kParamElementEGReleaseRate;
			break;
		}

		case ADDR(0x00, 0x04):
		case ADDR(0x00, 0x05):
		case ADDR(0x00, 0x06):
		case ADDR(0x00, 0x07):
		{
			idx = addr & 3;
			value1 = data;

			voice->GetElement(elem)->SetLevelScaleBreakPoint(idx, value1);
			value2 = voice->GetElement(1 - elem)->GetLevelScaleBreakPoint(idx);

			param = kParamElementLevelScaleBreakPoint;
			break;
		}

		case ADDR(0x00, 0x09):
		case ADDR(0x00, 0x0B):
		case ADDR(0x00, 0x0D):
		case ADDR(0x00, 0x0F):
		{
			int byte = mSysExData[1];
			mSysExData[1] = 0xFF;

			if (byte & 0x80) return;
			byte = (unsigned char)(byte << 4) | (data & 0x0F);

			idx = (addr >> 1) & 3;
			value1 = byte;

			voice->GetElement(elem)->SetLevelScaleOffset(idx, value1);
			value2 = voice->GetElement(1 - elem)->GetLevelScaleOffset(idx);

			param = kParamElementLevelScaleOffset;
			break;
		}

		case ADDR(0x00, 0x10):
		{
			value1 = wdl_min(data, 15);

			voice->GetElement(elem)->SetPan(value1);
			value2 = voice->GetElement(1 - elem)->GetPan();

			param = kParamElementPan;
			break;
		}

		case ADDR(0x00, 0x11):
		{
			value1 = wdl_min(data, 7);

			voice->GetElement(elem)->SetLFOSpeed(value1);
			value2 = voice->GetElement(1 - elem)->GetLFOSpeed();

			param = kParamElementLFOSpeed;
			break;
		}

		case ADDR(0x00, 0x12):
		{
			value1 = data;

			voice->GetElement(elem)->SetLFODelay(value1);
			value2 = voice->GetElement(1 - elem)->GetLFODelay();

			param = kParamElementLFODelay;
			break;
		}

		case ADDR(0x00, 0x14):
		{
			value1 = wdl_min(data, 15);

			voice->GetElement(elem)->SetLFOPitchModDepth(value1);
			value2 = voice->GetElement(1 - elem)->GetLFOPitchModDepth();

			param = kParamElementLFOPitchModDepth;
			break;
		}

		case ADDR(0x00, 0x15):
		{
			value1 = wdl_min(data, 7);

			voice->GetElement(elem)->SetLFOAmpModDepth(value1);
			value2 = voice->GetElement(1 - elem)->GetLFOAmpModDepth();

			param = kParamElementLFOAmpModDepth;
			break;
		}

		case ADDR(0x00, 0x16):
		{
			value1 = wdl_min(data, kPitchLFOSampleHold);

			voice->GetElement(elem)->SetPitchLFOWave(value1);
			value2 = voice->GetElement(1 - elem)->GetPitchLFOWave();

			param = kParamElementPitchLFOWave;
			break;
		}

		case ADDR(0x00, 0x17):
		{
			// TN: Undocumented kPEGRange8 isn't supported via SysEx.
			value1 = wdl_min(data, kPEGRange2);

			voice->GetElement(elem)->SetPitchEGRange(value1);
			value2 = voice->GetElement(1 - elem)->GetPitchEGRange();

			param = kParamElementPitchEGRange;
			break;
		}

		case ADDR(0x00, 0x18):
		{
			value1 = wdl_min(data, 1);

			voice->GetElement(elem)->SetPitchEGVelocitySwitch(value1);
			value2 = voice->GetElement(1 - elem)->GetPitchEGVelocitySwitch();

			param = kParamElementPitchEGVelocitySwitch;
			break;
		}

		case ADDR(0x00, 0x19):
		{
			value1 = wdl_min(data, 7);
			
			voice->GetElement(elem)->SetPitchEGRateScale(value1);
			value2 = voice->GetElement(1 - elem)->GetPitchEGRateScale();

			param = kParamElementPitchEGRateScale;
			break;
		}

		case ADDR(0x00, 0x1A):
		case ADDR(0x00, 0x1B):
		case ADDR(0x00, 0x1C):
		case ADDR(0x00, 0x1D):
		{
			idx = addr - ADDR(0x00, 0x1A);
			value1 = wdl_min(data, 63);

			voice->GetElement(elem)->SetPitchEGRate(idx, value1);
			value2 = voice->GetElement(1 - elem)->GetPitchEGRate(idx);

			param = kParamElementPitchEGRate;
			break;
		}

		case ADDR(0x00, 0x1E):
		case ADDR(0x00, 0x1F):
		case ADDR(0x00, 0x20):
		case ADDR(0x00, 0x21):
		case ADDR(0x00, 0x22):
		{
			idx = addr - ADDR(0x00, 0x1E);
			value1 = data;

			voice->GetElement(elem)->SetPitchEGLevel(idx, value1);
			value2 = voice->GetElement(1 - elem)->GetPitchEGLevel(idx);

			param = kParamElementPitchEGLevel;
			break;
		}

		case ADDR(0x00, 0x23):
		{
			value1 = wdl_min(data, 7);
			
			voice->GetElement(elem)->SetVelocityCurve(value1);
			value2 = voice->GetElement(1 - elem)->GetVelocityCurve();

			param = kParamElementVelocityCurve;
			break;
		}

		default: return;
	}

	SetParamChange(param, prog);

	mParamChange[2] = voice->GetVoiceMode();
	mParamChange[3] = elem;
	mParamChange[4] = idx;

	unsigned char* const elemChange = &mParamChange[wdl_min(idx, 0) + 5];

	elemChange[(unsigned int)(elem /* - kVoiceElement1 */)] = value1;
	elemChange[(unsigned int)(kVoiceElement2 - elem)] = value2;
}

#undef ADDR

void Engine::SetParamChange(const EParamChange param, const int data)
{
	assert(param != kParamChangeNone);

	#ifndef NDEBUG
	memset(&mParamChange[0], 0xFF, 7);
	memset(&mParamChange[8], 0xFF, 8);
	#endif

	mParamChange[0] = param;
	mParamChange[1] = data;
}

int Engine::SerializeState(void* const buf, const int bufSize)
{
	assert(GetStatus() == true);

	if (bufSize < kStateSize) return 0;

	assert(mDrumSetup[kNumDrumNotes].mBuf - mSystem.mBuf == kStateSize);
	memcpy(buf, mSystem.mBuf, kStateSize);

	assert(mMultiPart[0].mBuf - mSystem.mBuf == kSystemSize);
	unsigned char* ptr = (unsigned char*)buf + kSystemSize;

	ptr[1] = mPartData[kPartDrums].mVoiceBank[1];

	for (int i = 1; i < kNumParts; ++i)
	{
		ptr += sizeof(MultiPart);
		memcpy(ptr, mPartData[i].mVoiceBank, 2);
	}

	return kStateSize;
}

int Engine::UnserializeState(const void* const buf, const int bufSize, const bool paramChange)
{
	assert(GetStatus() == true);

	if (bufSize < kStateSize) return 0;

	assert(mDrumSetup[kNumDrumNotes].mBuf - mSystem.mBuf == kStateSize);
	memcpy(mSystem.mBuf, buf, kStateSize);

	for (int i = 0; i < kMaxNumPoly; ++i)
	{
		FastRelease(&mWaveGen[i]);

		mNoteOnCounter[i] = 0;
		mWaveData[i].mNote = 0x80;
	}

	UpdatePartList();

	const int partNo = paramChange ? 1 : -1;

	for (int i = 0; i < kNumParts; ++i)
	{
		MonoData* const monoData = &mMonoData[i];

		monoData->mNumNotes = 0;
		memset(monoData->mAlloc, 0xFF, 2);

		const int prog = mMultiPart[i].GetProgram();
		int bank;

		const char* const name = LoadProgram(i, prog, &bank);
		if (!(i == partNo && name)) continue;

		static const int mode = kModeGeneralMidi;
		SetParamChange(kParamUnserializeState, mode);

		mParamChange[2] = partNo;
		mParamChange[3] = bank;
		mParamChange[4] = prog;

		memcpy(&mParamChange[8], name, 8);
	}

	return kStateSize;
}

} // namespace TG101