/*
 * Load_symmod.cpp
 * ---------------
 * Purpose: SymMOD (Symphonie / Symphonie Pro) module loader
 * Notes  : Based in part on Patrick Meng's Java-based Symphonie player and its source.
 *          Some effect behaviour and other things are based on the original Amiga assembly source.
 *          Symphonie is an interesting beast, with a surprising combination of features and lack thereof.
 *          It offers advanced DSPs (for its time) but has a fixed track tempo. It can handle stereo samples
 *          but free panning support was only added in one of the very last versions. Still, a good number
 *          of high-quality modules were made with it despite (or because of) its lack of features.
 * Authors: Devin Acker
 *          OpenMPT Devs
 * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
 */

#include "stdafx.h"
#include "Loaders.h"
#include "Mixer.h"
#include "MixFuncTable.h"
#include "modsmp_ctrl.h"
#include "openmpt/soundbase/SampleConvert.hpp"
#include "openmpt/soundbase/SampleConvertFixedPoint.hpp"
#include "openmpt/soundbase/SampleDecode.hpp"
#include "SampleCopy.h"
#ifdef MPT_EXTERNAL_SAMPLES
#include "../common/mptPathString.h"
#endif  // MPT_EXTERNAL_SAMPLES
#include "mpt/base/numbers.hpp"

#include <map>

OPENMPT_NAMESPACE_BEGIN

struct SymFileHeader
{
	char     magic[4];  // "SymM"
	uint32be version;

	bool Validate() const
	{
		return !std::memcmp(magic, "SymM", 4) && version == 1;
	}
};

MPT_BINARY_STRUCT(SymFileHeader, 8)


struct SymEvent
{
	enum Command : uint8
	{
		KeyOn = 0,
		VolSlideUp,
		VolSlideDown,
		PitchSlideUp,
		PitchSlideDown,
		ReplayFrom,
		FromAndPitch,
		SetFromAdd,
		FromAdd,
		SetSpeed,
		AddPitch,
		AddVolume,
		Tremolo,
		Vibrato,
		SampleVib,
		PitchSlideTo,
		Retrig,
		Emphasis,
		AddHalfTone,
		CV,
		CVAdd,

		Filter = 23,
		DSPEcho,
		DSPDelay,
	};

	enum Volume : uint8
	{
		VolCommand  = 200,
		StopSample  = 254,
		ContSample  = 253,
		StartSample = 252,  // unused
		KeyOff      = 251,
		SpeedDown   = 250,
		SpeedUp     = 249,
		SetPitch    = 248,
		PitchUp     = 247,
		PitchDown   = 246,
		PitchUp2    = 245,
		PitchDown2  = 244,
		PitchUp3    = 243,
		PitchDown3  = 242
	};

	uint8be command;  // See Command enum
	int8be note;
	uint8be param;  // Volume if <= 100, see Volume enum otherwise
	uint8be inst;
	
	bool IsGlobal() const
	{
		if(command == SymEvent::SetSpeed || command == SymEvent::DSPEcho || command == SymEvent::DSPDelay)
			return true;
		if(command == SymEvent::KeyOn && (param == SymEvent::SpeedUp || param == SymEvent::SpeedDown))
			return true;
		return false;
	}

	// used to compare DSP events for mapping them to MIDI macro numbers
	bool operator<(const SymEvent &other) const
	{
		return std::tie(command, note, param, inst) < std::tie(other.command, other.note, other.param, other.inst);
	}
};

MPT_BINARY_STRUCT(SymEvent, 4)


struct SymVirtualHeader
{
	char     id[4];  // "ViRT"
	uint8be  zero;
	uint8be  filler1;
	uint16be version;  // 0 = regular, 1 = transwave
	uint16be mixInfo;  // unused, but not 0 in all modules
	uint16be filler2;
	uint16be eos;      // 0

	uint16be numEvents;
	uint16be maxEvents;  // always 20
	uint16be eventSize;  // 4 for virtual instruments, 10 for transwave instruments (number of cycles, not used)

	bool IsValid() const
	{
		return !memcmp(id, "ViRT", 4) && zero == 0 && version <= 1 && eos == 0 && maxEvents == 20;
	}

	bool IsVirtual() const
	{
		return IsValid() && version == 0 && numEvents <= 20 && eventSize == sizeof(SymEvent);
	}

	bool IsTranswave() const
	{
		return IsValid() && version == 1 && numEvents == 2 && eventSize == 10;
	}
};

MPT_BINARY_STRUCT(SymVirtualHeader, 20)


// Virtual instrument info
// This allows instruments to be created based on a mix of other instruments.
// The sample mixing is done at load time.
struct SymVirtualInst
{
	SymVirtualHeader header;
	SymEvent noteEvents[20];
	char padding[28];

	bool Render(CSoundFile &sndFile, const bool asQueue, ModSample &target, uint16 sampleBoost) const
	{
		if(header.numEvents < 1 || header.numEvents > std::size(noteEvents) || noteEvents[0].inst >= sndFile.GetNumSamples())
			return false;

		target.Initialize(MOD_TYPE_IT);
		target.uFlags = CHN_16BIT;

		const auto events = mpt::as_span(noteEvents).subspan(0, header.numEvents);
		const double rateFactor = 1.0 / std::max(sndFile.GetSample(events[0].inst + 1).nC5Speed, uint32(1));

		for(const auto &event : events.subspan(0, asQueue ? events.size() : 1u))
		{
			if(event.inst >= sndFile.GetNumSamples() || event.note < 0)
				continue;
			const ModSample &sourceSmp = sndFile.GetSample(event.inst + 1);
			const double length = sourceSmp.nLength * std::pow(2.0, (event.note - events[0].note) / -12.0) * sourceSmp.nC5Speed * rateFactor;
			target.nLength += mpt::saturate_round<SmpLength>(length);
		}
		if(!target.AllocateSample())
			return false;

		std::vector<ModChannel> channels(events.size());
		SmpLength lastSampleOffset = 0;
		for(size_t ev = 0; ev < events.size(); ev++)
		{
			const SymEvent &event = events[ev];
			ModChannel &chn = channels[ev];

			if(event.inst >= sndFile.GetNumSamples() || event.note < 0)
				continue;

			int8 finetune = 0;
			if(event.param >= SymEvent::PitchDown3 && event.param <= SymEvent::PitchUp)
			{
				static constexpr int8 PitchTable[] = {-4, 4, -2, 2, -1, 1};
				static_assert(mpt::array_size<decltype(PitchTable)>::size == SymEvent::PitchUp - SymEvent::PitchDown3 + 1);
				finetune = PitchTable[event.param - SymEvent::PitchDown3];
			}

			const ModSample &sourceSmp = sndFile.GetSample(event.inst + 1);
			const double increment = std::pow(2.0, (event.note - events[0].note) / 12.0 + finetune / 96.0) * sourceSmp.nC5Speed * rateFactor;
			if(increment <= 0)
				continue;

			chn.increment = SamplePosition::FromDouble(increment);
			chn.pCurrentSample = sourceSmp.samplev();
			chn.nLength = sourceSmp.nLength;
			chn.dwFlags = sourceSmp.uFlags & CHN_SAMPLEFLAGS;
			if(asQueue)
			{
				// This determines when the queued sample will be played
				chn.oldOffset = lastSampleOffset;
				lastSampleOffset += mpt::saturate_round<SmpLength>(chn.nLength / chn.increment.ToDouble());
			}
			int32 volume = 4096 * sampleBoost / 10000;  // avoid clipping the filters if the virtual sample is later also filtered (see e.g. 303 emulator.symmod)
			if(!asQueue)
				volume /= header.numEvents;
			chn.leftVol = chn.rightVol = volume;
		}

		SmpLength writeOffset = 0;
		while(writeOffset < target.nLength)
		{
			std::array<mixsample_t, MIXBUFFERSIZE * 2> buffer{};
			const SmpLength writeCount = std::min(static_cast<SmpLength>(MIXBUFFERSIZE), target.nLength - writeOffset);

			for(auto &chn : channels)
			{
				if(!chn.pCurrentSample)
					continue;
				// Should queued sample be played yet?
				if(chn.oldOffset >= writeCount)
				{
					chn.oldOffset -= writeCount;
					continue;
				}

				uint32 functionNdx = MixFuncTable::ndxLinear;
				if(chn.dwFlags[CHN_16BIT])
					functionNdx |= MixFuncTable::ndx16Bit;
				if(chn.dwFlags[CHN_STEREO])
					functionNdx |= MixFuncTable::ndxStereo;

				const SmpLength procCount = std::min(writeCount - chn.oldOffset, mpt::saturate_round<SmpLength>((chn.nLength - chn.position.ToDouble()) / chn.increment.ToDouble()));
				MixFuncTable::Functions[functionNdx](chn, sndFile.m_Resampler, buffer.data() + chn.oldOffset * 2, procCount);
				chn.oldOffset = 0;
				if(chn.position.GetUInt() >= chn.nLength)
					chn.pCurrentSample = nullptr;
			}
			CopySample<SC::ConversionChain<SC::ConvertFixedPoint<int16, mixsample_t, 27>, SC::DecodeIdentity<mixsample_t>>>(target.sample16() + writeOffset, writeCount, 1, buffer.data(), sizeof(buffer), 2);
			writeOffset += writeCount;
		}

		return true;
	}
};

MPT_BINARY_STRUCT(SymVirtualInst, 128)


// Transwave instrument info
// Similar to virtual instruments, allows blending between two sample loops
struct SymTranswaveInst
{
	struct Transwave
	{
		uint16be sourceIns;
		uint16be volume;  // According to source label - but appears to be unused
		uint32be loopStart;
		uint32be loopLen;
		uint32be padding;

		std::pair<SmpLength, SmpLength> ConvertLoop(const ModSample &mptSmp) const
		{
			const double loopScale = static_cast<double>(mptSmp.nLength) / (100 << 16);
			const SmpLength start  = mpt::saturate_cast<SmpLength>(loopScale * std::min(uint32(100 << 16), loopStart.get()));
			const SmpLength length = mpt::saturate_cast<SmpLength>(loopScale * std::min(uint32(100 << 16), loopLen.get()));
			return {start, std::min(mptSmp.nLength - start, length)};
		}
	};

	SymVirtualHeader header;
	Transwave points[2];
	char padding[76];

	// Morph between two sample loops
	bool Render(const ModSample &smp1, const ModSample &smp2, ModSample &target) const
	{
		target.Initialize(MOD_TYPE_IT);

		const auto [loop1Start, loop1Len] = points[0].ConvertLoop(smp1);
		const auto [loop2Start, loop2Len] = points[1].ConvertLoop(smp2);

		if(loop1Len < 1 || loop1Len > MAX_SAMPLE_LENGTH / (4u * 80u))
			return false;

		const SmpLength cycleLength = loop1Len * 4u;
		const double cycleFactor1 = loop1Len / static_cast<double>(cycleLength);
		const double cycleFactor2 = loop2Len / static_cast<double>(cycleLength);

		target.uFlags = CHN_16BIT;
		target.nLength = cycleLength * 80u;
		if(!target.AllocateSample())
			return false;

		const double ampFactor = 1.0 / target.nLength;
		for(SmpLength i = 0; i < cycleLength; i++)
		{
			const double v1 = TranswaveInterpolate(smp1, loop1Start + i * cycleFactor1);
			const double v2 = TranswaveInterpolate(smp2, loop2Start + i * cycleFactor2);
			SmpLength writeOffset = i;
			for(int cycle = 0; cycle < 80; cycle++, writeOffset += cycleLength)
			{
				const double amp = writeOffset * ampFactor;
				target.sample16()[writeOffset] = mpt::saturate_round<int16>(v1 * (1.0 - amp) + v2 * amp);
			}
		}

		return true;
	}

	static MPT_FORCEINLINE double TranswaveInterpolate(const ModSample &smp, double offset)
	{
		if(!smp.HasSampleData())
			return 0.0;

		SmpLength intOffset = static_cast<SmpLength>(offset);
		const double fractOffset = offset - intOffset;
		const uint8 numChannels = smp.GetNumChannels();
		intOffset *= numChannels;

		int16 v1, v2;
		if(smp.uFlags[CHN_16BIT])
		{
			v1 = smp.sample16()[intOffset];
			v2 = smp.sample16()[intOffset + numChannels];
		} else
		{
			v1 = smp.sample8()[intOffset] * 256;
			v2 = smp.sample8()[intOffset + numChannels] * 256;
		}
		return (v1 * (1.0 - fractOffset) + v2 * fractOffset);
	}
};

MPT_BINARY_STRUCT(SymTranswaveInst, 128)


// Instrument definition
struct SymInstrument
{
	using SymInstrumentName = std::array<char, 128>;

	SymVirtualInst virt;  // or SymInstrumentName, or SymTranswaveInst

	enum Type : int8
	{
		Silent  = -8,
		Kill    = -4,
		Normal  = 0,
		Loop    = 4,
		Sustain = 8
	};

	enum Channel : uint8
	{
		Mono,
		StereoL,
		StereoR,
		LineSrc  // virtual mix instrument
	};

	enum SampleFlags : uint8
	{
		PlayReverse   = 1,   // reverse sample
		AsQueue       = 2,   // "queue" virtual instrument (rendereds samples one after another rather than simultaneously)
		MirrorX       = 4,   // invert sample phase
		Is16Bit       = 8,   // not used, we already know the bit depth of the samples
		NewLoopSystem = 16,  // use fine loop start/len values

		MakeNewSample = (PlayReverse | MirrorX)
	};

	enum InstFlags : uint8
	{
		NoTranspose = 1,  // don't apply sequence/position transpose
		NoDSP       = 2,  // don't apply DSP effects
		SyncPlay    = 4   // play a stereo instrument pair (or two copies of the same mono instrument) on consecutive channels
	};

	int8be   type;  // see Type enum
	uint8be  loopStartHigh;
	uint8be  loopLenHigh;
	uint8be  numRepetitions;  // for "sustain" instruments
	uint8be  channel;         // see Channel enum
	uint8be  dummy1;          // called "automaximize" (normalize?) in Amiga source, but unused
	uint8be  volume;          // 0-199
	uint8be  dummy2[3];       // info about "parent/child" and sample format
	int8be   finetune;        // -128..127 ~= 2 semitones
	int8be   transpose;
	uint8be  sampleFlags;  // see SampleFlags enum
	int8be   filter;       // negative: highpass, positive: lowpass
	uint8be  instFlags;    // see InstFlags enum
	uint8be  downsample;   // downsample factor; affects sample tuning
	uint8be  dummy3[2];    // resonance, "loadflags" (both unused)
	uint8be  info;         // bit 0 should indicate that rangeStart/rangeLen are valid, but they appear to be unused
	uint8be  rangeStart;   // ditto
	uint8be  rangeLen;     // ditto
	uint8be  dummy4;
	uint16be loopStartFine;
	uint16be loopLenFine;
	uint8be  dummy5[6];

	uint8be filterFlags;      // bit 0 = enable, bit 1 = highpass
	uint8be numFilterPoints;  // # of filter envelope points (up to 4, possibly only 1-2 ever actually used)
	struct SymFilterSetting
	{
		uint8be cutoff;
		uint8be resonance;
	} filterPoint[4];

	uint8be volFadeFlag;
	uint8be volFadeFrom;
	uint8be volFadeTo;
	
	uint8be padding[83];

	bool IsVirtual() const
	{
		return virt.header.IsValid();
	}

	// Valid instrument either is virtual or has a name
	bool IsEmpty() const
	{
		return virt.header.id[0] == 0 || type < 0;
	}
	
	std::string GetName() const
	{
		return mpt::String::ReadBuf(mpt::String::maybeNullTerminated, mpt::bit_cast<SymInstrumentName>(virt));
	}

	SymTranswaveInst GetTranswave() const
	{
		return mpt::bit_cast<SymTranswaveInst>(virt);
	}

	void ConvertToMPT(ModInstrument &mptIns, ModSample &mptSmp, CSoundFile &sndFile) const
	{
		if(!IsVirtual())
			mptIns.name = mpt::String::ReadBuf(mpt::String::maybeNullTerminated, mpt::bit_cast<SymInstrumentName>(virt));

		mptSmp.uFlags.reset(CHN_LOOP | CHN_PINGPONGLOOP | CHN_SUSTAINLOOP | CHN_PANNING);  // Avoid these coming in from sample files

		const auto [loopStart, loopLen] = GetSampleLoop(mptSmp);
		if(type == Loop && loopLen > 0)
		{
			mptSmp.uFlags.set(CHN_LOOP);
			mptSmp.nLoopStart = loopStart;
			mptSmp.nLoopEnd   = loopStart + loopLen;
		}

		// volume (0-199, default 100)
		// Symphonie actually compresses the sample data if the volume is above 100 (see end of function)
		// We spread the volume between sample and instrument global volume if it's below 100 for the best possible resolution.
		// This can be simplified if instrument volume ever gets adjusted to 0...128 range like in IT.
		uint8 effectiveVolume = (volume > 0 && volume < 200) ? static_cast<uint8>(std::min(volume.get(), uint8(100)) * 128u / 100) : 128;
		mptSmp.nGlobalVol     = std::max(effectiveVolume, uint8(64)) / 2u;
		mptIns.nGlobalVol     = std::min(effectiveVolume, uint8(64));

		// Tuning info (we'll let our own mixer take care of the downsampling instead of doing it at load time)
		mptSmp.nC5Speed = 40460;
		mptSmp.Transpose(-downsample + (transpose / 12.0) + (finetune / (128.0 * 12.0)));

		// DSP settings
		mptIns.nMixPlug = (instFlags & NoDSP) ? 2 : 1;
		if(instFlags & NoDSP)
		{
			// This is not 100% correct: An instrument playing after this one should pick up previous filter settings.
			mptIns.SetCutoff(127, true);
			mptIns.SetResonance(0, true);
		}

		// Various sample processing follows
		if(!mptSmp.HasSampleData())
			return;

		if(sampleFlags & PlayReverse)
			ctrlSmp::ReverseSample(mptSmp, 0, 0, sndFile);
		if(sampleFlags & MirrorX)
			ctrlSmp::InvertSample(mptSmp, 0, 0, sndFile);

		// Always use 16-bit data to help with heavily filtered 8-bit samples (like in Future_Dream.SymMOD)
		const bool doVolFade = (volFadeFlag == 2) && (volFadeFrom <= 100) && (volFadeTo <= 100);
		if(!mptSmp.uFlags[CHN_16BIT] && (filterFlags || doVolFade || filter))
		{
			int16 *newSample = static_cast<int16 *>(ModSample::AllocateSample(mptSmp.nLength, 2 * mptSmp.GetNumChannels()));
			if(!newSample)
				return;
			CopySample<SC::ConversionChain<SC::Convert<int16, int8>, SC::DecodeIdentity<int8>>>(newSample, mptSmp.nLength * mptSmp.GetNumChannels(), 1, mptSmp.sample8(), mptSmp.GetSampleSizeInBytes(), 1);
			mptSmp.uFlags.set(CHN_16BIT);
			ctrlSmp::ReplaceSample(mptSmp, newSample, mptSmp.nLength, sndFile);
		}

		// Highpass
		if(filter < 0)
		{
			auto sampleData = mpt::as_span(mptSmp.sample16(), mptSmp.nLength * mptSmp.GetNumChannels());
			for(int i = 0; i < -filter; i++)
			{
				int32 mix = sampleData[0];
				for(auto &sample : sampleData)
				{
					mix    = mpt::rshift_signed(sample - mpt::rshift_signed(mix, 1), 1);
					sample = static_cast<int16>(mix);
				}
			}
		}

		// Volume Fade
		if(doVolFade)
		{
			auto sampleData = mpt::as_span(mptSmp.sample16(), mptSmp.nLength * mptSmp.GetNumChannels());
			int32 amp = volFadeFrom << 24, inc = Util::muldivr(volFadeTo - volFadeFrom, 1 << 24, static_cast<SmpLength>(sampleData.size()));
			for(auto &sample : sampleData)
			{
				sample = static_cast<int16>(Util::muldivr(sample, amp, 100 << 24));
				amp += inc;
			}
		}

		// Resonant Filter Sweep
		if(filterFlags != 0)
		{
			auto sampleData = mpt::as_span(mptSmp.sample16(), mptSmp.nLength * mptSmp.GetNumChannels());
			int32 cutoff = filterPoint[0].cutoff << 23, resonance = filterPoint[0].resonance << 23;
			const int32 cutoffStep = numFilterPoints > 1 ? Util::muldivr(filterPoint[1].cutoff - filterPoint[0].cutoff, 1 << 23, static_cast<SmpLength>(sampleData.size())) : 0;
			const int32 resoStep   = numFilterPoints > 1 ? Util::muldivr(filterPoint[1].resonance - filterPoint[0].resonance, 1 << 23, static_cast<SmpLength>(sampleData.size())) : 0;
			const uint8 highpass   = filterFlags & 2;

			int32 filterState[3]{};
			for(auto &sample : sampleData)
			{
				const int32 currentCutoff = cutoff / (1 << 23), currentReso = resonance / (1 << 23);
				cutoff += cutoffStep;
				resonance += resoStep;

				filterState[2] = mpt::rshift_signed(sample, 1) - filterState[0];
				filterState[1] += mpt::rshift_signed(currentCutoff * filterState[2], 8);
				filterState[0] += mpt::rshift_signed(currentCutoff * filterState[1], 6);
				filterState[0] += mpt::rshift_signed(currentReso * filterState[0], 6);
				filterState[0] = mpt::rshift_signed(filterState[0], 2);
				sample = mpt::saturate_cast<int16>(filterState[highpass]);
			}
		}

		// Lowpass
		if(filter > 0)
		{
			auto sampleData = mpt::as_span(mptSmp.sample16(), mptSmp.nLength * mptSmp.GetNumChannels());
			for(int i = 0; i < filter; i++)
			{
				int32 mix = sampleData[0];
				for(auto &sample : sampleData)
				{
					mix = (sample + sample + mix) / 3;
					sample = static_cast<int16>(mix);
				}
			}
		}

		// Symphonie normalizes samples at load time (it normalizes them to the sample boost value - but we will use the full 16-bit range)
		// Indeed, the left and right channel instruments are normalized separately.
		const auto Normalize = [](auto sampleData)
		{
			const auto scale              = Util::MaxValueOfType(sampleData[0]);
			const auto [minElem, maxElem] = std::minmax_element(sampleData.begin(), sampleData.end());
			const int max                 = std::max(-*minElem, +*maxElem);
			if(max >= scale || max == 0)
				return;

			for(auto &v : sampleData)
			{
				v = static_cast<typename std::remove_reference<decltype(v)>::type>(static_cast<int>(v) * scale / max);
			}
		};
		if(mptSmp.uFlags[CHN_16BIT])
			Normalize(mpt::as_span(mptSmp.sample16(), mptSmp.nLength * mptSmp.GetNumChannels()));
		else
			Normalize(mpt::as_span(mptSmp.sample8(), mptSmp.nLength * mptSmp.GetNumChannels()));

		// "Non-destructive" over-amplification with hard knee compression
		if(volume > 100 && volume < 200)
		{
			const auto Amplify = [](auto sampleData, const uint8 gain)
			{
				const int32 knee = 16384 * (200 - gain) / 100, kneeInv = 32768 - knee;
				constexpr int32 scale = 1 << (16 - (sizeof(sampleData[0]) * 8));
				for(auto &sample : sampleData)
				{
					int32 v = sample * scale;
					if(v > knee)
						v = (v - knee) * knee / kneeInv + kneeInv;
					else if(v < -knee)
						v = (v + knee) * knee / kneeInv - kneeInv;
					else
						v = v * kneeInv / knee;
					sample = mpt::saturate_cast<typename std::remove_reference<decltype(sample)>::type>(v / scale);
				}
			};

			const auto length = mptSmp.nLength * mptSmp.GetNumChannels();
			if(mptSmp.uFlags[CHN_16BIT])
				Amplify(mpt::span(mptSmp.sample16(), mptSmp.sample16() + length), volume);
			else
				Amplify(mpt::span(mptSmp.sample8(), mptSmp.sample8() + length), volume);
		}

		// This must be applied last because some sample processors are time-dependent and Symphonie would be doing this during playback instead
		mptSmp.RemoveAllCuePoints();
		if(type == Sustain && numRepetitions > 0 && loopLen > 0)
		{
			mptSmp.cues[0] = loopStart + loopLen * (numRepetitions + 1u);
			mptSmp.nSustainStart = loopStart;  // This is of purely informative value and not used for playback
			mptSmp.nSustainEnd   = loopStart + loopLen;

			if(MAX_SAMPLE_LENGTH / numRepetitions < loopLen)
				return;
			if(MAX_SAMPLE_LENGTH - numRepetitions * loopLen < mptSmp.nLength)
				return;

			const uint8 bps      = mptSmp.GetBytesPerSample();
			SmpLength loopEnd    = loopStart + loopLen * (numRepetitions + 1);
			SmpLength newLength  = mptSmp.nLength + loopLen * numRepetitions;
			std::byte *newSample = static_cast<std::byte *>(ModSample::AllocateSample(newLength, bps));
			if(!newSample)
				return;

			mptSmp.nLength = newLength;
			std::memcpy(newSample, mptSmp.sampleb(), (loopStart + loopLen) * bps);
			for(uint8 i = 0; i < numRepetitions; i++)
			{
				std::memcpy(newSample + (loopStart + loopLen * (i + 1)) * bps, mptSmp.sampleb() + loopStart * bps, loopLen * bps);
			}
			std::memcpy(newSample + loopEnd * bps, mptSmp.sampleb() + (loopStart + loopLen) * bps, (newLength - loopEnd) * bps);
			
			ctrlSmp::ReplaceSample(mptSmp, newSample, mptSmp.nLength, sndFile);
		}
	}

	std::pair<SmpLength, SmpLength> GetSampleLoop(const ModSample &mptSmp) const
	{
		if(type != Loop && type != Sustain)
			return {0, 0};

		SmpLength loopStart = static_cast<SmpLength>(std::min(loopStartHigh.get(), uint8(100)));
		SmpLength loopLen = static_cast<SmpLength>(std::min(loopLenHigh.get(), uint8(100)));
		if(sampleFlags & NewLoopSystem)
		{
			loopStart = (loopStart << 16) + loopStartFine;
			loopLen = (loopLen << 16) + loopLenFine;

			const double loopScale = static_cast<double>(mptSmp.nLength) / (100 << 16);
			loopStart = mpt::saturate_cast<SmpLength>(loopStart * loopScale);
			loopLen = std::min(mptSmp.nLength - loopStart, mpt::saturate_cast<SmpLength>(loopLen * loopScale));
		} else if(mptSmp.HasSampleData())
		{
			// The order of operations here may seem weird as it reduces precision, but it's taken directly from the original assembly source (UpdateRecalcLoop)
			loopStart = ((loopStart << 7) / 100u) * (mptSmp.nLength >> 7);
			loopLen = std::min(mptSmp.nLength - loopStart, ((loopLen << 7) / 100u) * (mptSmp.nLength >> 7));

			const auto FindLoopEnd = [](auto sampleData, const uint8 numChannels, SmpLength loopStart, SmpLength loopLen, const int threshold)
			{
				const auto valAtStart = sampleData.data()[loopStart * numChannels];
				auto *endPtr = sampleData.data() + (loopStart + loopLen) * numChannels;
				while(loopLen)
				{
					if(std::abs(*endPtr - valAtStart) < threshold)
						return loopLen;
					endPtr -= numChannels;
					loopLen--;
				}
				return loopLen;
			};
			if(mptSmp.uFlags[CHN_16BIT])
				loopLen = FindLoopEnd(mpt::as_span(mptSmp.sample16(), mptSmp.nLength * mptSmp.GetNumChannels()), mptSmp.GetNumChannels(), loopStart, loopLen, 6 * 256);
			else
				loopLen = FindLoopEnd(mpt::as_span(mptSmp.sample8(), mptSmp.nLength * mptSmp.GetNumChannels()), mptSmp.GetNumChannels(), loopStart, loopLen, 6);
		}

		return {loopStart, loopLen};
	}
};

MPT_BINARY_STRUCT(SymInstrument, 256)


struct SymSequence
{
	uint16be start;
	uint16be length;
	uint16be loop;
	int16be  info;
	int16be  transpose;

	uint8be  padding[6];
};

MPT_BINARY_STRUCT(SymSequence, 16)


struct SymPosition
{
	uint8be  dummy[4];
	uint16be loopNum;
	uint16be loopCount;  // Only used during playback
	uint16be pattern;
	uint16be start;
	uint16be length;
	uint16be speed;
	int16be  transpose;
	uint16be eventsPerLine;  // Unused

	uint8be  padding[12];

	// Used to compare position entries for mapping them to OpenMPT patterns
	bool operator<(const SymPosition &other) const
	{
		return std::tie(pattern, start, length, transpose, speed) < std::tie(other.pattern, other.start, other.length, other.transpose, other.speed);
	}
};

MPT_BINARY_STRUCT(SymPosition, 32)


static std::vector<std::byte> DecodeSymChunk(FileReader &file)
{
	std::vector<std::byte> data;
	const uint32 packedLength = file.ReadUint32BE();
	if(!file.CanRead(packedLength))
	{
		file.Skip(file.BytesLeft());
		return data;
	}

	FileReader chunk = file.ReadChunk(packedLength);
	if(packedLength >= 10 && chunk.ReadMagic("PACK\xFF\xFF"))
	{
		// RLE-compressed chunk
		uint32 unpackedLength = chunk.ReadUint32BE();
		// The best compression ratio can be achieved with type 1, where six bytes turn into up to 255*4 bytes, a ratio of 1:170.
		uint32 maxLength = packedLength - 10;
		if(Util::MaxValueOfType(maxLength) / 170 >= maxLength)
			maxLength *= 170;
		else
			maxLength = Util::MaxValueOfType(maxLength);
		LimitMax(unpackedLength, maxLength);
		data.resize(unpackedLength);

		bool done = false;
		uint32 offset = 0, remain = unpackedLength;

		while(!done && !chunk.EndOfFile())
		{
			uint8 len;
			std::array<std::byte, 4> dword;

			const int8 type = chunk.ReadInt8();
			switch(type)
			{
			case 0:
				// Copy raw bytes
				len = chunk.ReadUint8();
				if(remain >= len && chunk.CanRead(len))
				{
					chunk.ReadRaw(mpt::as_span(data).subspan(offset, len));
					offset += len;
					remain -= len;
				} else
				{
					done = true;
				}
				break;

			case 1:
				// Copy a dword multiple times
				len = chunk.ReadUint8();
				if(remain >= (len * 4u) && chunk.ReadArray(dword))
				{
					remain -= len * 4u;
					while(len--)
					{
						std::copy(dword.begin(), dword.end(), data.begin() + offset);
						offset += 4;
					}
				} else
				{
					done = true;
				}
				break;

			case 2:
				// Copy a dword twice
				if(remain >= 8 && chunk.ReadArray(dword))
				{
					std::copy(dword.begin(), dword.end(), data.begin() + offset);
					std::copy(dword.begin(), dword.end(), data.begin() + offset + 4);
					offset += 8;
					remain -= 8;
				} else
				{
					done = true;
				}
				break;

			case 3:
				// Zero bytes
				len = chunk.ReadUint8();
				if(remain >= len)
				{
					// vector is already initialized to zero
					offset += len;
					remain -= len;
				} else
				{
					done = true;
				}
				break;

			case -1:
				done = true;
				break;

			default:
				// error
				done = true;
				break;
			}
		}

#ifndef MPT_BUILD_FUZZER
		// When using a fuzzer, we should not care if the decompressed buffer has the correct size.
		// This makes finding new interesting test cases much easier.
		if(remain)
			std::vector<std::byte>{}.swap(data);
#endif
	} else
	{
		// Uncompressed chunk
		chunk.ReadVector(data, packedLength);
	}

	return data;
}


template<typename T>
static std::vector<T> DecodeSymArray(FileReader &file)
{
	const auto data = DecodeSymChunk(file);
	FileReader chunk(mpt::as_span(data));
	std::vector<T> retVal;
	chunk.ReadVector(retVal, data.size() / sizeof(T));
	return retVal;
}


static bool ReadRawSymSample(ModSample &sample, FileReader &file)
{
	SampleIO sampleIO(SampleIO::_16bit, SampleIO::mono, SampleIO::bigEndian, SampleIO::signedPCM);
	SmpLength nullBytes = 0;
	sample.Initialize();

	file.Rewind();
	if(file.ReadMagic("MAESTRO"))
	{
		file.Seek(12);
		if(file.ReadUint32BE() == 0)
			sampleIO |= SampleIO::stereoInterleaved;
		file.Seek(24);
	} else if(file.ReadMagic("16BT"))
	{
		file.Rewind();
		nullBytes = 4;  // In Symphonie, the anti-click would take care of those...
	} else
	{
		sampleIO |= SampleIO::_8bit;
	}

	sample.nLength = mpt::saturate_cast<SmpLength>(file.BytesLeft() / (sampleIO.GetNumChannels() * sampleIO.GetBitDepth() / 8u));
	const bool ok = sampleIO.ReadSample(sample, file) > 0;

	if(ok && nullBytes)
		std::memset(sample.samplev(), 0, std::min(nullBytes, sample.GetSampleSizeInBytes()));

	return ok;
}


static std::vector<std::byte> DecodeSample8(FileReader &file)
{
	auto data = DecodeSymChunk(file);
	uint8 lastVal = 0;
	for(auto &val : data)
	{
		lastVal += mpt::byte_cast<uint8>(val);
		val = mpt::byte_cast<std::byte>(lastVal);
	}

	return data;
}


static std::vector<std::byte> DecodeSample16(FileReader &file)
{
	auto data = DecodeSymChunk(file);
	std::array<std::byte, 4096> buf;
	constexpr size_t blockSize = buf.size() / 2;  // Size of block in 16-bit samples

	for(size_t block = 0; block < data.size() / buf.size(); block++)
	{
		const size_t offset = block * sizeof(buf);
		uint8 lastVal = 0;

		// Decode LSBs
		for(size_t i = 0; i < blockSize; i++)
		{
			lastVal += mpt::byte_cast<uint8>(data[offset + i]);
			buf[i * 2 + 1] = mpt::byte_cast<std::byte>(lastVal);
		}
		// Decode MSBs
		for(size_t i = 0; i < blockSize; i++)
		{
			lastVal += mpt::byte_cast<uint8>(data[offset + i + blockSize]);
			buf[i * 2] = mpt::byte_cast<std::byte>(lastVal);
		}

		std::copy(buf.begin(), buf.end(), data.begin() + offset);
	}

	return data;
}


static bool ConvertDSP(const SymEvent event, MIDIMacroConfigData::Macro &macro, const CSoundFile &sndFile)
{
	if(event.command == SymEvent::Filter)
	{
		// Symphonie practically uses the same filter for this as for the sample processing.
		// The cutoff and resonance are an approximation.
		const uint8 type = event.note % 5u;
		const uint8 cutoff = sndFile.FrequencyToCutOff(event.param * 10000.0 / 240.0);
		const uint8 reso = static_cast<uint8>(std::min(127, event.inst * 127 / 185));

		if(type == 1)  // lowpass filter
			macro = MPT_AFORMAT("F0F000{} F0F001{} F0F00200")(mpt::afmt::HEX0<2>(cutoff), mpt::afmt::HEX0<2>(reso));
		else if(type == 2)  // highpass filter
			macro = MPT_AFORMAT("F0F000{} F0F001{} F0F00210")(mpt::afmt::HEX0<2>(cutoff), mpt::afmt::HEX0<2>(reso));
		else  // no filter or unsupported filter type
			macro = "F0F0007F F0F00100";
		return true;
	} else if(event.command == SymEvent::DSPEcho)
	{
		const uint8 type = (event.note < 5) ? event.note : 0;
		const uint8 length = (event.param < 128) ? event.param : 127;
		const uint8 feedback = (event.inst < 128) ? event.inst : 127;
		macro = MPT_AFORMAT("F0F080{} F0F081{} F0F082{}")(mpt::afmt::HEX0<2>(type), mpt::afmt::HEX0<2>(length), mpt::afmt::HEX0<2>(feedback));
		return true;
	} else if(event.command == SymEvent::DSPDelay)
	{
		// DSP first has to be turned on from the Symphonie GUI before it can be used in a track (unlike Echo),
		// so it's not implemented for now.
		return false;
	}
	return false;
}


CSoundFile::ProbeResult CSoundFile::ProbeFileHeaderSymMOD(MemoryFileReader file, const uint64 *pfilesize)
{
	MPT_UNREFERENCED_PARAMETER(pfilesize);
	SymFileHeader fileHeader;
	if(!file.ReadStruct(fileHeader))
		return ProbeWantMoreData;
	if(!fileHeader.Validate())
		return ProbeFailure;
	if(!file.CanRead(sizeof(uint32be)))
		return ProbeWantMoreData;
	if(file.ReadInt32BE() >= 0)
		return ProbeFailure;
	return ProbeSuccess;
}


bool CSoundFile::ReadSymMOD(FileReader &file, ModLoadingFlags loadFlags)
{
	file.Rewind();
	SymFileHeader fileHeader;
	if(!file.ReadStruct(fileHeader) || !fileHeader.Validate())
		return false;
	if(file.ReadInt32BE() >= 0)
		return false;
	else if(loadFlags == onlyVerifyHeader)
		return true;

	InitializeGlobals(MOD_TYPE_MPT);

	m_SongFlags.set(SONG_LINEARSLIDES | SONG_EXFILTERRANGE | SONG_IMPORTED);
	m_playBehaviour = GetDefaultPlaybackBehaviour(MOD_TYPE_IT);
	m_playBehaviour.reset(kITShortSampleRetrig);

	enum class ChunkType : int32
	{
		NumChannels     = -1,
		TrackLength     = -2,
		PatternSize     = -3,
		NumInstruments  = -4,
		EventSize       = -5,
		Tempo           = -6,
		ExternalSamples = -7,
		PositionList    = -10,
		SampleFile      = -11,
		EmptySample     = -12,
		PatternEvents   = -13,
		InstrumentList  = -14,
		Sequences       = -15,
		InfoText        = -16,
		SamplePacked    = -17,
		SamplePacked16  = -18,
		InfoType        = -19,
		InfoBinary      = -20,
		InfoString      = -21,

		SampleBoost     = 10,  // All samples will be normalized to this value
		StereoDetune    = 11,  // Note: Not affected by no-DSP flag in instrument! So this would need to have its own plugin...
		StereoPhase     = 12,
	};

	uint32 trackLen      = 0;
	uint16 sampleBoost   = 2500;
	bool isSymphoniePro  = false;
	bool externalSamples = false;
	std::vector<SymPosition> positions;
	std::vector<SymSequence> sequences;
	std::vector<SymEvent> patternData;
	std::vector<SymInstrument> instruments;

	file.SkipBack(sizeof(int32));
	while(file.CanRead(sizeof(int32)))
	{
		const ChunkType chunkType = static_cast<ChunkType>(file.ReadInt32BE());
		switch(chunkType)
		{
		// Simple values
		case ChunkType::NumChannels:
			if(auto numChannels = static_cast<CHANNELINDEX>(file.ReadUint32BE()); !m_nChannels && numChannels > 0 && numChannels <= MAX_BASECHANNELS)
			{
				m_nChannels = numChannels;
				m_nSamplePreAmp = Clamp(512 / m_nChannels, 16, 128);
			}
			break;

		case ChunkType::TrackLength:
			trackLen = file.ReadUint32BE();
			if(trackLen > 1024)
				return false;
			break;

		case ChunkType::EventSize:
			if(auto eventSize = (file.ReadUint32BE() & 0xFFFF); eventSize != sizeof(SymEvent))
				return false;
			break;

		case ChunkType::Tempo:
			m_nDefaultTempo = TEMPO(1.24 * std::min(file.ReadUint32BE(), uint32(800)));
			break;

		// Unused values
		case ChunkType::NumInstruments:  // determined from # of instrument headers instead
		case ChunkType::PatternSize:
			file.Skip(4);
			break;

		case ChunkType::SampleBoost:
			sampleBoost    = static_cast<uint16>(Clamp(file.ReadUint32BE(), 0u, 10000u));
			isSymphoniePro = true;
			break;

		case ChunkType::StereoDetune:
		case ChunkType::StereoPhase:
			isSymphoniePro = true;
			if(uint32 val = file.ReadUint32BE(); val != 0)
				AddToLog(LogWarning, U_("Stereo Detune / Stereo Phase is not supported"));
			break;

		case ChunkType::ExternalSamples:
			file.Skip(4);
			if(!m_nSamples)
				externalSamples = true;
			break;

		// Binary chunk types
		case ChunkType::PositionList:
			if((loadFlags & loadPatternData) && positions.empty())
				positions = DecodeSymArray<SymPosition>(file);
			else
				file.Skip(file.ReadUint32BE());
			break;

		case ChunkType::SampleFile:
		case ChunkType::SamplePacked:
		case ChunkType::SamplePacked16:
			if(m_nSamples >= instruments.size())
				break;
			if(!externalSamples && (loadFlags & loadSampleData) && CanAddMoreSamples())
			{
				const SAMPLEINDEX sample = ++m_nSamples;

				std::vector<std::byte> unpackedSample;
				FileReader chunk;
				if(chunkType == ChunkType::SampleFile)
				{
					chunk = file.ReadChunk(file.ReadUint32BE());
				} else if(chunkType == ChunkType::SamplePacked)
				{
					unpackedSample = DecodeSample8(file);
					chunk = FileReader(mpt::as_span(unpackedSample));
				} else  // SamplePacked16
				{
					unpackedSample = DecodeSample16(file);
					chunk = FileReader(mpt::as_span(unpackedSample));
				}

				if(!ReadIFFSample(sample, chunk)
				   && !ReadWAVSample(sample, chunk)
				   && !ReadAIFFSample(sample, chunk)
				   && !ReadRawSymSample(Samples[sample], chunk))
				{
					AddToLog(LogWarning, U_("Unknown sample format."));
				}

				// Symphonie represents stereo instruments as two consecutive mono instruments which are
				// automatically played at the same time. If this one uses a stereo sample, split it
				// and map two OpenMPT instruments to the stereo halves to ensure correct playback
				if(Samples[sample].uFlags[CHN_STEREO] && CanAddMoreSamples())
				{
					const SAMPLEINDEX sampleL = ++m_nSamples;
					ctrlSmp::SplitStereo(Samples[sample], Samples[sampleL], Samples[sample], *this);
					Samples[sampleL].filename = "Left";
					Samples[sample].filename = "Right";
				} else if(sample < instruments.size() && instruments[sample].channel == SymInstrument::StereoR && CanAddMoreSamples())
				{
					// Prevent misalignment of samples in exit.symmod (see condition in MoveNextMonoInstrument in Symphonie source)
					m_nSamples++;
				}
			} else
			{
				// Skip sample
				file.Skip(file.ReadUint32BE());
			}
			break;

		case ChunkType::EmptySample:
			if(CanAddMoreSamples())
				m_nSamples++;
			break;

		case ChunkType::PatternEvents:
			if((loadFlags & loadPatternData) && patternData.empty())
				patternData = DecodeSymArray<SymEvent>(file);
			else
				file.Skip(file.ReadUint32BE());
			break;

		case ChunkType::InstrumentList:
			if(instruments.empty())
				instruments = DecodeSymArray<SymInstrument>(file);
			else
				file.Skip(file.ReadUint32BE());
			break;

		case ChunkType::Sequences:
			if((loadFlags & loadPatternData) && sequences.empty())
				sequences = DecodeSymArray<SymSequence>(file);
			else
				file.Skip(file.ReadUint32BE());
			break;

		case ChunkType::InfoText:
			if(const auto text = DecodeSymChunk(file); !text.empty())
				m_songMessage.Read(text.data(), text.size(), SongMessage::leLF);
			break;

		// Unused binary chunks
		case ChunkType::InfoType:
		case ChunkType::InfoBinary:
		case ChunkType::InfoString:
			file.Skip(file.ReadUint32BE());
			break;

		// Unrecognized chunk/value type
		default:
			return false;
		}
	}

	if(!m_nChannels || !trackLen || instruments.empty())
		return false;
	if((loadFlags & loadPatternData) && (positions.empty() || patternData.empty() || sequences.empty()))
		return false;

	// Let's hope noone is going to use the 256th instrument ;)
	if(instruments.size() >= MAX_INSTRUMENTS)
		instruments.resize(MAX_INSTRUMENTS - 1u);
	m_nInstruments = static_cast<INSTRUMENTINDEX>(instruments.size());
	static_assert(MAX_SAMPLES >= MAX_INSTRUMENTS);
	m_nSamples = std::max(m_nSamples, m_nInstruments);

	// Supporting this is probably rather useless, as the paths will always be full Amiga paths. We just take the filename without path for now.
	if(externalSamples)
	{
#ifdef MPT_EXTERNAL_SAMPLES
		m_nSamples = m_nInstruments;
		for(SAMPLEINDEX sample = 1; sample <= m_nSamples; sample++)
		{
			const SymInstrument &symInst = instruments[sample - 1];
			if(symInst.IsEmpty() || symInst.IsVirtual())
				continue;
			
			auto filename = mpt::PathString::FromUnicode(mpt::ToUnicode(mpt::Charset::Amiga_no_C1, symInst.GetName()));
			if(file.GetOptionalFileName())
				filename = file.GetOptionalFileName()->GetPath() + filename.GetFullFileName();
			
			if(!LoadExternalSample(sample, filename))
				AddToLog(LogError, MPT_UFORMAT("Unable to load sample {}: {}")(sample, filename));
			else
				ResetSamplePath(sample);

			if(Samples[sample].uFlags[CHN_STEREO] && sample < m_nSamples)
			{
				const SAMPLEINDEX sampleL = sample + 1;
				ctrlSmp::SplitStereo(Samples[sample], Samples[sampleL], Samples[sample], *this);
				Samples[sampleL].filename = "Left";
				Samples[sample].filename = "Right";
				sample++;
			}
		}
#else
		AddToLog(LogWarning, U_("External samples are not supported."));
#endif  // MPT_EXTERNAL_SAMPLES
	}

	// Convert instruments
	for(int pass = 0; pass < 2; pass++)
	{
		for(INSTRUMENTINDEX ins = 1; ins <= m_nInstruments; ins++)
		{
			SymInstrument &symInst = instruments[ins - 1];
			if(symInst.IsEmpty())
				continue;
			// First load all regular instruments, and when we have the required information, render the virtual ones
			if(symInst.IsVirtual() != (pass == 1))
				continue;

			SAMPLEINDEX sample = ins;
			if(symInst.virt.header.IsVirtual())
			{
				const uint8 firstSource = symInst.virt.noteEvents[0].inst;
				ModSample &target = Samples[sample];
				if(symInst.virt.Render(*this, symInst.sampleFlags & SymInstrument::AsQueue, target, sampleBoost))
				{
					m_szNames[sample] = "Virtual";
					if(firstSource < instruments.size())
						symInst.downsample += instruments[firstSource].downsample;
				} else
				{
					sample = firstSource + 1;
				}
			} else if(symInst.virt.header.IsTranswave())
			{
				const SymTranswaveInst transwaveInst = symInst.GetTranswave();
				const auto &trans1 = transwaveInst.points[0], &trans2 = transwaveInst.points[1];
				if(trans1.sourceIns < m_nSamples)
				{
					const ModSample emptySample;
					const ModSample &smp1 = Samples[trans1.sourceIns + 1];
					const ModSample &smp2 = trans2.sourceIns < m_nSamples ? Samples[trans2.sourceIns + 1] : emptySample;
					ModSample &target     = Samples[sample];
					if(transwaveInst.Render(smp1, smp2, target))
					{
						m_szNames[sample] = "Transwave";
						// Transwave instruments play an octave lower than the original source sample, but are 4x oversampled,
						// so effectively they play an octave higher
						symInst.transpose += 12;
					}
				}
			}

			if(ModInstrument *instr = AllocateInstrument(ins, sample); instr != nullptr && sample <= m_nSamples)
				symInst.ConvertToMPT(*instr, Samples[sample], *this);
		}
	}

	// Convert patterns
	// map Symphonie positions to converted patterns
	std::map<SymPosition, PATTERNINDEX> patternMap;
	// map DSP commands to MIDI macro numbers
	std::map<SymEvent, uint8> macroMap;

	bool useDSP = false;
	const uint32 patternSize = m_nChannels * trackLen;
	const PATTERNINDEX numPatterns = mpt::saturate_cast<PATTERNINDEX>(patternData.size() / patternSize);

	Patterns.ResizeArray(numPatterns);
	Order().clear();

	struct ChnState
	{
		float curVolSlide      = 0;      // Current volume slide factor of a channel
		float curVolSlideAmt   = 0;      // Cumulative volume slide amount
		float curPitchSlide    = 0;      // Current pitch slide factor of a channel
		float curPitchSlideAmt = 0;      // Cumulative pitch slide amount
		bool stopped           = false;  // Sample paused or not (affects volume and pitch slides)
		uint8 lastNote         = 0;      // Last note played on a channel
		uint8 lastInst         = 0;      // Last instrument played on a channel
		uint8 lastVol          = 64;     // Last specified volume of a channel (to avoid excessive Mxx commands)
		uint8 channelVol       = 100;    // Volume multiplier, 0...100
		uint8 calculatedVol    = 64;     // Final channel volume
		uint8 fromAdd          = 0;      // Base sample offset for FROM and FR&P effects
		uint8 curVibrato       = 0;
		uint8 curTremolo       = 0;
		uint8 sampleVibSpeed   = 0;
		uint8 sampleVibDepth   = 0;
		uint8 tonePortaAmt     = 0;
		uint16 sampleVibPhase  = 0;
		uint16 retriggerRemain = 0;
		uint16 tonePortaRemain = 0;
	};
	std::vector<ChnState> chnStates(m_nChannels);

	// In Symphonie, sequences represent the structure of a song, and not separate songs like in OpenMPT. Hence they will all be loaded into the same ModSequence.
	for(SymSequence &seq : sequences)
	{
		if(seq.info == 1)
			continue;
		if(seq.info == -1)
			break;

		if(seq.start >= positions.size()
		   || seq.length > positions.size()
		   || seq.length == 0
		   || positions.size() - seq.length < seq.start)
			continue;
		auto seqPositions = mpt::as_span(positions).subspan(seq.start, seq.length);

		// Sequences are all part of the same song, just add a skip index as a divider
		ModSequence &order = Order();
		if(!order.empty())
			order.push_back(ModSequence::GetIgnoreIndex());

		for(auto &pos : seqPositions)
		{
			// before checking the map, apply the sequence transpose value
			pos.transpose += seq.transpose;

			// pattern already converted?
			PATTERNINDEX patternIndex = 0;
			if(patternMap.count(pos))
			{
				patternIndex = patternMap[pos];
			} else if(loadFlags & loadPatternData)
			{
				// Convert pattern now
				patternIndex = Patterns.InsertAny(pos.length);
				if(patternIndex == PATTERNINDEX_INVALID)
					break;

				patternMap[pos] = patternIndex;

				if(pos.pattern >= numPatterns || pos.start >= trackLen)
					continue;

				uint8 patternSpeed = static_cast<uint8>(pos.speed);

				// This may intentionally read into the next pattern
				auto srcEvent = patternData.cbegin() + (pos.pattern * patternSize) + (pos.start * m_nChannels);
				const SymEvent emptyEvent{};
				ModCommand syncPlayCommand;
				for(ROWINDEX row = 0; row < pos.length; row++)
				{
					ModCommand *rowBase = Patterns[patternIndex].GetpModCommand(row, 0);
					bool applySyncPlay = false;
					for(CHANNELINDEX chn = 0; chn < m_nChannels; chn++)
					{
						ModCommand &m = rowBase[chn];
						const SymEvent &event = (srcEvent != patternData.cend()) ? *srcEvent : emptyEvent;
						if(srcEvent != patternData.cend())
							srcEvent++;

						int8 note = (event.note >= 0 && event.note <= 84) ? event.note + 25 : -1;
						uint8 origInst = event.inst;
						uint8 mappedInst = 0;
						if(origInst < instruments.size())
						{
							mappedInst = static_cast<uint8>(origInst + 1);
							if(!(instruments[origInst].instFlags & SymInstrument::NoTranspose) && note >= 0)
								note = Clamp(static_cast<int8>(note + pos.transpose), NOTE_MIN, NOTE_MAX);
						}

						// If we duplicated a stereo channel to this cell but the event is non-empty, remove it again.
						if(m.note != NOTE_NONE && (event.command != SymEvent::KeyOn || event.note != -1 || event.inst != 0 || event.param != 0)
							&& m.instr > 0 && m.instr <= instruments.size() && instruments[m.instr - 1].channel == SymInstrument::StereoR)
						{
							m.Clear();
						}

						auto &chnState = chnStates[chn];

						if(applySyncPlay)
						{
							applySyncPlay = false;
							m = syncPlayCommand;
							if(m.command == CMD_NONE && chnState.calculatedVol != chnStates[chn - 1].calculatedVol)
							{
								m.command = CMD_CHANNELVOLUME;
								m.param = chnState.calculatedVol = chnStates[chn - 1].calculatedVol;
							}
							if(!event.IsGlobal())
								continue;
						}

						bool applyVolume = false;
						switch(static_cast<SymEvent::Command>(event.command.get()))
						{
						case SymEvent::KeyOn:
							if(event.param > SymEvent::VolCommand)
							{
								switch(event.param)
								{
								case SymEvent::StopSample:
									m.volcmd = VOLCMD_PLAYCONTROL;
									m.vol = 0;
									chnState.stopped = true;
									break;

								case SymEvent::ContSample:
									m.volcmd = VOLCMD_PLAYCONTROL;
									m.vol = 1;
									chnState.stopped = false;
									break;

								case SymEvent::KeyOff:
									if(m.note == NOTE_NONE)
										m.note = chnState.lastNote;
									m.volcmd = VOLCMD_OFFSET;
									m.vol = 1;
									break;

								case SymEvent::SpeedDown:
									if(patternSpeed > 1)
									{
										m.command = CMD_SPEED;
										m.param = --patternSpeed;
									}
									break;

								case SymEvent::SpeedUp:
									if(patternSpeed < 0xFF)
									{
										m.command = CMD_SPEED;
										m.param = ++patternSpeed;
									}
									break;

								case SymEvent::SetPitch:
									chnState.lastNote = note;
									if(mappedInst != chnState.lastInst)
										break;
									m.note = note;
									m.command = CMD_TONEPORTAMENTO;
									m.param = 0xFF;
									chnState.curPitchSlide = 0;
									chnState.tonePortaRemain = 0;
									break;

								// fine portamentos with range up to half a semitone
								case SymEvent::PitchUp:
									m.command = CMD_PORTAMENTOUP;
									m.param = 0xF2;
									break;
								case SymEvent::PitchDown:
									m.command = CMD_PORTAMENTODOWN;
									m.param = 0xF2;
									break;
								case SymEvent::PitchUp2:
									m.command = CMD_PORTAMENTOUP;
									m.param = 0xF4;
									break;
								case SymEvent::PitchDown2:
									m.command = CMD_PORTAMENTODOWN;
									m.param = 0xF4;
									break;
								case SymEvent::PitchUp3:
									m.command = CMD_PORTAMENTOUP;
									m.param = 0xF8;
									break;
								case SymEvent::PitchDown3:
									m.command = CMD_PORTAMENTODOWN;
									m.param = 0xF8;
									break;
								}
							} else
							{
								if(event.note >= 0 || event.param < 100)
								{
									if(event.note >= 0)
									{
										m.note = chnState.lastNote = note;
										m.instr = chnState.lastInst = mappedInst;
										chnState.curPitchSlide = 0;
										chnState.tonePortaRemain = 0;
									}

									if(event.param > 0)
									{
										chnState.lastVol = mpt::saturate_round<uint8>(event.param * 0.64);
										if(chnState.curVolSlide != 0)
											applyVolume = true;
										chnState.curVolSlide = 0;
									}
								}
							}

							if(const uint8 newVol = static_cast<uint8>(Util::muldivr_unsigned(chnState.lastVol, chnState.channelVol, 100));
							   applyVolume || chnState.calculatedVol != newVol)
							{
								chnState.calculatedVol = newVol;
								m.command = CMD_CHANNELVOLUME;
								m.param = newVol;
							}

							// Key-On commands with stereo instruments are played on both channels - unless there's already some sort of event
							if(event.note > 0 && (chn < m_nChannels - 1) && !(chn % 2u)
							   && origInst < instruments.size() && instruments[origInst].channel == SymInstrument::StereoL)
							{
								ModCommand &next = rowBase[chn + 1];
								next = m;
								next.instr++;

								chnStates[chn + 1].lastVol = chnState.lastVol;
								chnStates[chn + 1].curVolSlide = chnState.curVolSlide;
								chnStates[chn + 1].curVolSlideAmt = chnState.curVolSlideAmt;
								chnStates[chn + 1].curPitchSlide = chnState.curPitchSlide;
								chnStates[chn + 1].curPitchSlideAmt = chnState.curPitchSlideAmt;
								chnStates[chn + 1].retriggerRemain = chnState.retriggerRemain;
							}

							break;

							// volume effects
							// Symphonie has very fine fractional volume slides which are applied at the output sample rate,
							// rather than per tick or per row, so instead let's simulate it based on the pattern speed
							// by keeping track of the volume and using normal volume commands
							// the math here is an approximation which works fine for most songs
						case SymEvent::VolSlideUp:
							chnState.curVolSlideAmt = 0;
							chnState.curVolSlide = event.param * 0.0333f;
							break;
						case SymEvent::VolSlideDown:
							chnState.curVolSlideAmt = 0;
							chnState.curVolSlide = event.param * -0.0333f;
							break;

						case SymEvent::AddVolume:
							m.command = m.param = 0;
							break;
						case SymEvent::Tremolo:
						{
							// both tremolo speed and depth can go much higher than OpenMPT supports,
							// but modules will probably use pretty sane, supportable values anyway
							// TODO: handle very small nonzero params
							uint8 speed = std::min<uint8>(15, event.inst >> 3);
							uint8 depth = std::min<uint8>(15, event.param >> 3);
							chnState.curTremolo = (speed << 4) | depth;
						}
							break;

							// pitch effects
							// Pitch slides have a similar granularity to volume slides, and are approximated
							// the same way here based on a rough comparison against Exx/Fxx slides
						case SymEvent::PitchSlideUp:
							chnState.curPitchSlideAmt = 0;
							chnState.curPitchSlide = event.param * 0.0333f;
							chnState.tonePortaRemain = 0;
							break;
						case SymEvent::PitchSlideDown:
							chnState.curPitchSlideAmt = 0;
							chnState.curPitchSlide = event.param * -0.0333f;
							chnState.tonePortaRemain = 0;
							break;

						case SymEvent::PitchSlideTo:
							if(note >= 0 && event.param > 0)
							{
								const int distance = std::abs((note - chnState.lastNote) * 32);
								chnState.curPitchSlide = 0;
								m.note = chnState.lastNote = note;
								m.command = CMD_TONEPORTAMENTO;
								chnState.tonePortaAmt = m.param = mpt::saturate_cast<ModCommand::PARAM>(distance / (2 * event.param));
								chnState.tonePortaRemain = static_cast<uint16>(distance - std::min(distance, chnState.tonePortaAmt * (patternSpeed - 1)));
							}
							break;
						case SymEvent::AddPitch:
							// "The range (-128...127) is about 4 half notes."
							m.command = m.param = 0;
							break;
						case SymEvent::Vibrato:
						{
							// both vibrato speed and depth can go much higher than OpenMPT supports,
							// but modules will probably use pretty sane, supportable values anyway
							// TODO: handle very small nonzero params
							uint8 speed = std::min<uint8>(15, event.inst >> 3);
							uint8 depth = std::min<uint8>(15, event.param);
							chnState.curVibrato = (speed << 4) | depth;
						}
							break;
						case SymEvent::AddHalfTone:
							m.note = chnState.lastNote = Clamp(static_cast<uint8>(chnState.lastNote + event.param), NOTE_MIN, NOTE_MAX);
							m.command = CMD_TONEPORTAMENTO;
							m.param = 0xFF;
							chnState.tonePortaRemain = 0;
							break;

							// DSP effects
						case SymEvent::Filter:
#ifndef NO_PLUGINS
						case SymEvent::DSPEcho:
						case SymEvent::DSPDelay:
#endif
							if(macroMap.count(event))
							{
								m.command = CMD_MIDI;
								m.param = macroMap[event];
							} else if(macroMap.size() < m_MidiCfg.Zxx.size())
							{
								uint8 param = static_cast<uint8>(macroMap.size());
								if(ConvertDSP(event, m_MidiCfg.Zxx[param], *this))
								{
									m.command = CMD_MIDI;
									m.param = macroMap[event] = 0x80 | param;

									if(event.command == SymEvent::DSPEcho || event.command == SymEvent::DSPDelay)
										useDSP = true;
								}
							}
							break;

							// other effects
						case SymEvent::Retrig:
							// This plays the note <param> times every <inst>+1 ticks.
							// The effect continues on the following rows until the correct amount is reached.
							if(event.param < 1)
								break;
							m.command = CMD_RETRIG;
							m.param = static_cast<uint8>(std::min(15, event.inst + 1));
							chnState.retriggerRemain = event.param * (event.inst + 1u);
							break;

						case SymEvent::SetSpeed:
							m.command = CMD_SPEED;
							m.param = patternSpeed = event.param ? event.param : 4u;
							break;

							// TODO this applies a fade on the sample level
						case SymEvent::Emphasis:
							m.command = CMD_NONE;
							break;
						case SymEvent::CV:
							if(event.note == 0 || event.note == 4)
							{
								uint8 pan  = (event.note == 4) ? event.inst : 128;
								uint8 vol  = std::min<uint8>(event.param, 100);
								uint8 volL = static_cast<uint8>(vol * std::min(128, 256 - pan) / 128);
								uint8 volR = static_cast<uint8>(vol * std::min(uint8(128), pan) / 128);

								if(volL != chnState.channelVol)
								{
									chnState.channelVol = volL;

									m.command = CMD_CHANNELVOLUME;
									m.param   = chnState.calculatedVol = static_cast<uint8>(Util::muldivr_unsigned(chnState.lastVol, chnState.channelVol, 100));
								}
								if(event.note == 4 && chn < (m_nChannels - 1) && chnStates[chn + 1].channelVol != volR)
								{
									chnStates[chn + 1].channelVol = volR;

									ModCommand &next = rowBase[chn + 1];
									next.command = CMD_CHANNELVOLUME;
									next.param   = chnState.calculatedVol = static_cast<uint8>(Util::muldivr_unsigned(chnState.lastVol, chnState.channelVol, 100));
								}
							}
							break;
						case SymEvent::CVAdd:
							// Effect doesn't seem to exist in UI and code looks like a no-op
							m.command = CMD_NONE;
							break;

						case SymEvent::SetFromAdd:
							chnState.fromAdd = event.param;
							chnState.sampleVibSpeed = 0;
							chnState.sampleVibDepth = 0;
							break;
						case SymEvent::FromAdd:
							// TODO need to verify how signedness of this value is treated
							// C = -128...+127
							//FORMEL: Neuer FADD := alter FADD + C* Samplelaenge/16384
							chnState.fromAdd += event.param;
							break;

						case SymEvent::SampleVib:
							chnState.sampleVibSpeed = event.inst;
							chnState.sampleVibDepth = event.param;
							break;

							// sample effects
						case SymEvent::FromAndPitch:
							chnState.lastNote = note;
							m.instr = chnState.lastInst = mappedInst;
							[[fallthrough]];
						case SymEvent::ReplayFrom:
							m.note = chnState.lastNote;
							if(note >= 0)
								m.instr = chnState.lastInst = mappedInst;
							if(event.command == SymEvent::ReplayFrom)
							{
								m.volcmd = VOLCMD_TONEPORTAMENTO;
								m.vol = 1;
							}
							// don't always add the command, because often FromAndPitch is used with offset 0
							// to act as a key-on which doesn't cancel volume slides, etc
							if(event.param || chnState.fromAdd || chnState.sampleVibDepth)
							{
								double sampleVib = 0.0;
								if(chnState.sampleVibDepth)
									sampleVib = chnState.sampleVibDepth * (std::sin(chnState.sampleVibPhase * (mpt::numbers::pi * 2.0 / 1024.0) + 1.5 * mpt::numbers::pi) - 1.0) / 4.0;
								m.command = CMD_OFFSETPERCENTAGE;
								m.param   = mpt::saturate_round<ModCommand::PARAM>(event.param + chnState.fromAdd + sampleVib);
							}
							chnState.tonePortaRemain = 0;
							break;
						}

						// Any event which plays a note should re-enable continuous effects
						if(m.note != NOTE_NONE)
							chnState.stopped = false;
						else if(chnState.stopped)
							continue;

						if(chnState.retriggerRemain)
						{
							chnState.retriggerRemain = std::max(chnState.retriggerRemain, static_cast<uint16>(patternSpeed)) - patternSpeed;
							if(m.command == CMD_NONE)
							{
								m.command = CMD_RETRIG;
								m.param = 0;
							}
						}

						// Handle fractional volume slides
						if(chnState.curVolSlide != 0)
						{
							chnState.curVolSlideAmt += chnState.curVolSlide * patternSpeed;
							if(m.command == CMD_NONE)
							{
								if(patternSpeed > 1 && chnState.curVolSlideAmt >= (patternSpeed - 1))
								{
									uint8 slideAmt = std::min<uint8>(15, mpt::saturate_round<uint8>(chnState.curVolSlideAmt / (patternSpeed - 1)));
									chnState.curVolSlideAmt -= slideAmt * (patternSpeed - 1);
									// normal slide up
									m.command = CMD_CHANNELVOLSLIDE;
									m.param = slideAmt << 4;
								} else if(chnState.curVolSlideAmt >= 1.0f)
								{
									uint8 slideAmt = std::min<uint8>(15, mpt::saturate_round<uint8>(chnState.curVolSlideAmt));
									chnState.curVolSlideAmt -= slideAmt;
									// fine slide up
									m.command = CMD_CHANNELVOLSLIDE;
									m.param = (slideAmt << 4) | 0x0F;
								} else if(patternSpeed > 1 && chnState.curVolSlideAmt <= -(patternSpeed - 1))
								{
									uint8 slideAmt = std::min<uint8>(15, mpt::saturate_round<uint8>(-chnState.curVolSlideAmt / (patternSpeed - 1)));
									chnState.curVolSlideAmt += slideAmt * (patternSpeed - 1);
									// normal slide down
									m.command = CMD_CHANNELVOLSLIDE;
									m.param = slideAmt;
								} else if(chnState.curVolSlideAmt <= -1.0f)
								{
									uint8 slideAmt = std::min<uint8>(14, mpt::saturate_round<uint8>(-chnState.curVolSlideAmt));
									chnState.curVolSlideAmt += slideAmt;
									// fine slide down
									m.command = CMD_CHANNELVOLSLIDE;
									m.param = slideAmt | 0xF0;
								}
							}
						}
						// Handle fractional pitch slides
						if(chnState.curPitchSlide != 0)
						{
							chnState.curPitchSlideAmt += chnState.curPitchSlide * patternSpeed;
							if(m.command == CMD_NONE)
							{
								if(patternSpeed > 1 && chnState.curPitchSlideAmt >= (patternSpeed - 1))
								{
									uint8 slideAmt = std::min<uint8>(0xDF, mpt::saturate_round<uint8>(chnState.curPitchSlideAmt / (patternSpeed - 1)));
									chnState.curPitchSlideAmt -= slideAmt * (patternSpeed - 1);
									// normal slide up
									m.command = CMD_PORTAMENTOUP;
									m.param = slideAmt;
								} else if(chnState.curPitchSlideAmt >= 1.0f)
								{
									uint8 slideAmt = std::min<uint8>(15, mpt::saturate_round<uint8>(chnState.curPitchSlideAmt));
									chnState.curPitchSlideAmt -= slideAmt;
									// fine slide up
									m.command = CMD_PORTAMENTOUP;
									m.param = slideAmt | 0xF0;
								} else if(patternSpeed > 1 && chnState.curPitchSlideAmt <= -(patternSpeed - 1))
								{
									uint8 slideAmt = std::min<uint8>(0xDF, mpt::saturate_round<uint8>(-chnState.curPitchSlideAmt / (patternSpeed - 1)));
									chnState.curPitchSlideAmt += slideAmt * (patternSpeed - 1);
									// normal slide down
									m.command = CMD_PORTAMENTODOWN;
									m.param = slideAmt;
								} else if(chnState.curPitchSlideAmt <= -1.0f)
								{
									uint8 slideAmt = std::min<uint8>(14, mpt::saturate_round<uint8>(-chnState.curPitchSlideAmt));
									chnState.curPitchSlideAmt += slideAmt;
									// fine slide down
									m.command = CMD_PORTAMENTODOWN;
									m.param = slideAmt | 0xF0;
								}
							}
							// TODO: use volume column if effect column is occupied
							else if(m.volcmd == VOLCMD_NONE)
							{
								if(patternSpeed > 1 && chnState.curPitchSlideAmt / 4 >= (patternSpeed - 1))
								{
									uint8 slideAmt = std::min<uint8>(9, mpt::saturate_round<uint8>(chnState.curPitchSlideAmt / (patternSpeed - 1)) / 4);
									chnState.curPitchSlideAmt -= slideAmt * (patternSpeed - 1) * 4;
									m.volcmd = VOLCMD_PORTAUP;
									m.vol = slideAmt;
								} else if(patternSpeed > 1 && chnState.curPitchSlideAmt / 4 <= -(patternSpeed - 1))
								{
									uint8 slideAmt = std::min<uint8>(9, mpt::saturate_round<uint8>(-chnState.curPitchSlideAmt / (patternSpeed - 1)) / 4);
									chnState.curPitchSlideAmt += slideAmt * (patternSpeed - 1) * 4;
									m.volcmd = VOLCMD_PORTADOWN;
									m.vol = slideAmt;
								}
							}
						}
						// Vibrato and Tremolo
						if(m.command == CMD_NONE && chnState.curVibrato != 0)
						{
							m.command = CMD_VIBRATO;
							m.param = chnState.curVibrato;
						}
						if(m.command == CMD_NONE && chnState.curTremolo != 0)
						{
							m.command = CMD_TREMOLO;
							m.param = chnState.curTremolo;
						}
						// Tone Portamento
						if(m.command != CMD_TONEPORTAMENTO && chnState.tonePortaRemain)
						{
							if(m.command == CMD_NONE)
								m.command = CMD_TONEPORTAMENTO;
							else
								m.volcmd = VOLCMD_TONEPORTAMENTO;
							chnState.tonePortaRemain -= std::min(chnState.tonePortaRemain, static_cast<uint16>(chnState.tonePortaAmt * (patternSpeed - 1)));
						}

						chnState.sampleVibPhase = (chnState.sampleVibPhase + chnState.sampleVibSpeed * patternSpeed) & 1023;

						if(!(chn % 2u) && chnState.lastInst && chnState.lastInst <= instruments.size()
						   && (instruments[chnState.lastInst - 1].instFlags & SymInstrument::SyncPlay))
						{
							syncPlayCommand = m;
							applySyncPlay = true;
							if(syncPlayCommand.instr && instruments[chnState.lastInst - 1].channel == SymInstrument::StereoL)
								syncPlayCommand.instr++;
						}
					}
				}

				Patterns[patternIndex].WriteEffect(EffectWriter(CMD_SPEED, static_cast<uint8>(pos.speed)).Row(0).RetryNextRow());
			}
			order.insert(order.GetLength(), std::max(pos.loopNum.get(), uint16(1)), patternIndex);
			// Undo transpose tweak
			pos.transpose -= seq.transpose;
		}
	}

#ifndef NO_PLUGINS
	if(useDSP)
	{
		SNDMIXPLUGIN &plugin = m_MixPlugins[0];
		plugin.Destroy();
		memcpy(&plugin.Info.dwPluginId1, "SymM", 4);
		memcpy(&plugin.Info.dwPluginId2, "Echo", 4);
		plugin.Info.routingFlags    = SNDMIXPLUGININFO::irAutoSuspend;
		plugin.Info.mixMode         = 0;
		plugin.Info.gain            = 10;
		plugin.Info.reserved        = 0;
		plugin.Info.dwOutputRouting = 0;
		std::fill(plugin.Info.dwReserved, plugin.Info.dwReserved + std::size(plugin.Info.dwReserved), 0);
		plugin.Info.szName        = "Echo";
		plugin.Info.szLibraryName = "SymMOD Echo";

		m_MixPlugins[1].Info.szName = "No Echo";
	}
#endif // NO_PLUGINS

	// Channel panning
	for(CHANNELINDEX chn = 0; chn < m_nChannels; chn++)
	{
		InitChannel(chn);
		ChnSettings[chn].nPan = (chn & 1) ? 256 : 0;
		ChnSettings[chn].nMixPlugin = useDSP ? 1 : 0;  // For MIDI macros controlling the echo DSP
	}

	m_modFormat.formatName = U_("Symphonie");
	m_modFormat.type = U_("symmod");
	if(!isSymphoniePro)
		m_modFormat.madeWithTracker = U_("Symphonie");  // or Symphonie Jr
	else if(instruments.size() <= 128)
		m_modFormat.madeWithTracker = U_("Symphonie Pro");
	else
		m_modFormat.madeWithTracker = U_("Symphonie Pro 256");
	m_modFormat.charset = mpt::Charset::Amiga_no_C1;

	return true;
}

OPENMPT_NAMESPACE_END
