path: root/Src/external_dependencies/openmpt-trunk/soundlib/Load_dtm.cpp

/*
 * Load_dtm.cpp
 * ------------
 * Purpose: Digital Tracker / Digital Home Studio module Loader (DTM)
 * Notes  : (currently none)
 * Authors: OpenMPT Devs
 * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
 */


#include "stdafx.h"
#include "Loaders.h"

OPENMPT_NAMESPACE_BEGIN

enum PatternFormats : uint32
{
	DTM_PT_PATTERN_FORMAT = 0,
	DTM_204_PATTERN_FORMAT = MagicBE("2.04"),
	DTM_206_PATTERN_FORMAT = MagicBE("2.06"),
};


struct DTMFileHeader
{
	char     magic[4];
	uint32be headerSize;
	uint16be type;        // 0 = module
	uint8be  stereoMode;  // FF = panoramic stereo, 00 = old stereo
	uint8be  bitDepth;    // Typically 8, sometimes 16, but is not actually used anywhere?
	uint16be reserved;    // Usually 0, but not in unknown title 1.dtm and unknown title 2.dtm
	uint16be speed;
	uint16be tempo;
	uint32be forcedSampleRate; // Seems to be ignored in newer files
};

MPT_BINARY_STRUCT(DTMFileHeader, 22)


// IFF-style Chunk
struct DTMChunk
{
	// 32-Bit chunk identifiers
	enum ChunkIdentifiers
	{
		idS_Q_ = MagicBE("S.Q."),
		idPATT = MagicBE("PATT"),
		idINST = MagicBE("INST"),
		idIENV = MagicBE("IENV"),
		idDAPT = MagicBE("DAPT"),
		idDAIT = MagicBE("DAIT"),
		idTEXT = MagicBE("TEXT"),
		idPATN = MagicBE("PATN"),
		idTRKN = MagicBE("TRKN"),
		idVERS = MagicBE("VERS"),
		idSV19 = MagicBE("SV19"),
	};

	uint32be id;
	uint32be length;

	size_t GetLength() const
	{
		return length;
	}

	ChunkIdentifiers GetID() const
	{
		return static_cast<ChunkIdentifiers>(id.get());
	}
};

MPT_BINARY_STRUCT(DTMChunk, 8)


struct DTMSample
{
	uint32be reserved;   // 0x204 for first sample, 0x208 for second, etc...
	uint32be length;     // in bytes
	uint8be  finetune;   // -8....7
	uint8be  volume;     // 0...64
	uint32be loopStart;  // in bytes
	uint32be loopLength; // ditto
	char     name[22];
	uint8be  stereo;
	uint8be  bitDepth;
	uint16be transpose;
	uint16be unknown;
	uint32be sampleRate;

	void ConvertToMPT(ModSample &mptSmp, uint32 forcedSampleRate, uint32 formatVersion) const
	{
		mptSmp.Initialize(MOD_TYPE_IT);
		mptSmp.nLength = length;
		mptSmp.nLoopStart = loopStart;
		mptSmp.nLoopEnd = mptSmp.nLoopStart + loopLength;
		// In revolution to come.dtm, the file header says samples rate is 24512 Hz, but samples say it's 50000 Hz
		// Digital Home Studio ignores the header setting in 2.04-/2.06-style modules
		mptSmp.nC5Speed = (formatVersion == DTM_PT_PATTERN_FORMAT && forcedSampleRate > 0) ? forcedSampleRate : sampleRate;
		int32 transposeAmount = MOD2XMFineTune(finetune);
		if(formatVersion == DTM_206_PATTERN_FORMAT && transpose > 0 && transpose != 48)
		{
			// Digital Home Studio applies this unconditionally, but some old songs sound wrong then (delirium.dtm).
			// Digital Tracker 2.03 ignores the setting.
			// Maybe this should not be applied for "real" Digital Tracker modules?
			transposeAmount += (48 - transpose) * 128;
		}
		mptSmp.Transpose(transposeAmount * (1.0 / (12.0 * 128.0)));
		mptSmp.nVolume = std::min(volume.get(), uint8(64)) * 4u;
		if(stereo & 1)
		{
			mptSmp.uFlags.set(CHN_STEREO);
			mptSmp.nLength /= 2u;
			mptSmp.nLoopStart /= 2u;
			mptSmp.nLoopEnd /= 2u;
		}
		if(bitDepth > 8)
		{
			mptSmp.uFlags.set(CHN_16BIT);
			mptSmp.nLength /= 2u;
			mptSmp.nLoopStart /= 2u;
			mptSmp.nLoopEnd /= 2u;
		}
		if(mptSmp.nLoopEnd > mptSmp.nLoopStart + 1)
		{
			mptSmp.uFlags.set(CHN_LOOP);
		} else
		{
			mptSmp.nLoopStart = mptSmp.nLoopEnd = 0;
		}
	}
};

MPT_BINARY_STRUCT(DTMSample, 50)


struct DTMInstrument
{
	uint16be insNum;
	uint8be  unknown1;
	uint8be  envelope; // 0xFF = none
	uint8be  sustain;  // 0xFF = no sustain point
	uint16be fadeout;
	uint8be  vibRate;
	uint8be  vibDepth;
	uint8be  modulationRate;
	uint8be  modulationDepth;
	uint8be  breathRate;
	uint8be  breathDepth;
	uint8be  volumeRate;
	uint8be  volumeDepth;
};

MPT_BINARY_STRUCT(DTMInstrument, 15)


struct DTMEnvelope
{
	struct DTMEnvPoint
	{
		uint8be value;
		uint8be tick;
	};
	uint16be numPoints;
	DTMEnvPoint points[16];
};

MPT_BINARY_STRUCT(DTMEnvelope::DTMEnvPoint, 2)
MPT_BINARY_STRUCT(DTMEnvelope, 34)


struct DTMText
{
	uint16be textType;	// 0 = pattern, 1 = free, 2 = song
	uint32be textLength;
	uint16be tabWidth;
	uint16be reserved;
	uint16be oddLength;
};

MPT_BINARY_STRUCT(DTMText, 12)


static bool ValidateHeader(const DTMFileHeader &fileHeader)
{
	if(std::memcmp(fileHeader.magic, "D.T.", 4)
		|| fileHeader.headerSize < sizeof(fileHeader) - 8u
		|| fileHeader.headerSize > 256 // Excessively long song title?
		|| fileHeader.type != 0)
	{
		return false;
	}
	return true;
}


CSoundFile::ProbeResult CSoundFile::ProbeFileHeaderDTM(MemoryFileReader file, const uint64 *pfilesize)
{
	DTMFileHeader fileHeader;
	if(!file.ReadStruct(fileHeader))
	{
		return ProbeWantMoreData;
	}
	if(!ValidateHeader(fileHeader))
	{
		return ProbeFailure;
	}
	MPT_UNREFERENCED_PARAMETER(pfilesize);
	return ProbeSuccess;
}


bool CSoundFile::ReadDTM(FileReader &file, ModLoadingFlags loadFlags)
{
	file.Rewind();

	DTMFileHeader fileHeader;
	if(!file.ReadStruct(fileHeader))
	{
		return false;
	}
	if(!ValidateHeader(fileHeader))
	{
		return false;
	}
	if(loadFlags == onlyVerifyHeader)
	{
		return true;
	}

	InitializeGlobals(MOD_TYPE_DTM);
	InitializeChannels();
	m_SongFlags.set(SONG_ITCOMPATGXX | SONG_ITOLDEFFECTS);
	m_playBehaviour.reset(kITVibratoTremoloPanbrello);
	// Various files have a default speed or tempo of 0
	if(fileHeader.tempo)
		m_nDefaultTempo.Set(fileHeader.tempo);
	if(fileHeader.speed)
		m_nDefaultSpeed = fileHeader.speed;
	if(fileHeader.stereoMode == 0)
		SetupMODPanning(true);

	file.ReadString<mpt::String::maybeNullTerminated>(m_songName, fileHeader.headerSize - (sizeof(fileHeader) - 8u));

	auto chunks = ChunkReader(file).ReadChunks<DTMChunk>(1);

	// Read order list
	if(FileReader chunk = chunks.GetChunk(DTMChunk::idS_Q_))
	{
		uint16 ordLen = chunk.ReadUint16BE();
		uint16 restartPos = chunk.ReadUint16BE();
		chunk.Skip(4);	// Reserved
		ReadOrderFromFile<uint8>(Order(), chunk, ordLen);
		Order().SetRestartPos(restartPos);
	} else
	{
		return false;
	}

	// Read pattern properties
	uint32 patternFormat;
	if(FileReader chunk = chunks.GetChunk(DTMChunk::idPATT))
	{
		m_nChannels = chunk.ReadUint16BE();
		if(m_nChannels < 1 || m_nChannels > 32)
		{
			return false;
		}
		Patterns.ResizeArray(chunk.ReadUint16BE());	// Number of stored patterns, may be lower than highest pattern number
		patternFormat = chunk.ReadUint32BE();
		if(patternFormat != DTM_PT_PATTERN_FORMAT && patternFormat != DTM_204_PATTERN_FORMAT && patternFormat != DTM_206_PATTERN_FORMAT)
		{
			return false;
		}
	} else
	{
		return false;
	}

	// Read global info
	if(FileReader chunk = chunks.GetChunk(DTMChunk::idSV19))
	{
		chunk.Skip(2);	// Ticks per quarter note, typically 24
		uint32 fractionalTempo = chunk.ReadUint32BE();
		m_nDefaultTempo = TEMPO(m_nDefaultTempo.GetInt() + fractionalTempo / 4294967296.0);

		uint16be panning[32];
		chunk.ReadArray(panning);
		for(CHANNELINDEX chn = 0; chn < 32 && chn < GetNumChannels(); chn++)
		{
			// Panning is in range 0...180, 90 = center
			ChnSettings[chn].nPan = static_cast<uint16>(128 + Util::muldivr(std::min(static_cast<int>(panning[chn]), int(180)) - 90, 128, 90));
		}

		chunk.Skip(16);
		// Chunk ends here for old DTM modules
		if(chunk.CanRead(2))
		{
			m_nDefaultGlobalVolume = std::min(chunk.ReadUint16BE(), static_cast<uint16>(MAX_GLOBAL_VOLUME));
		}
		chunk.Skip(128);
		uint16be volume[32];
		if(chunk.ReadArray(volume))
		{
			for(CHANNELINDEX chn = 0; chn < 32 && chn < GetNumChannels(); chn++)
			{
				// Volume is in range 0...128, 64 = normal
				ChnSettings[chn].nVolume = static_cast<uint8>(std::min(static_cast<int>(volume[chn]), int(128)) / 2);
			}
			m_nSamplePreAmp *= 2;	// Compensate for channel volume range
		}
	}

	// Read song message
	if(FileReader chunk = chunks.GetChunk(DTMChunk::idTEXT))
	{
		DTMText text;
		chunk.ReadStruct(text);
		if(text.oddLength == 0xFFFF)
		{
			chunk.Skip(1);
		}
		m_songMessage.Read(chunk, chunk.BytesLeft(), SongMessage::leCRLF);
	}

	// Read sample headers
	if(FileReader chunk = chunks.GetChunk(DTMChunk::idINST))
	{
		uint16 numSamples = chunk.ReadUint16BE();
		bool newSamples = (numSamples >= 0x8000);
		numSamples &= 0x7FFF;
		if(numSamples >= MAX_SAMPLES || !chunk.CanRead(numSamples * (sizeof(DTMSample) + (newSamples ? 2u : 0u))))
		{
			return false;
		}
		
		m_nSamples = numSamples;
		for(SAMPLEINDEX smp = 1; smp <= numSamples; smp++)
		{
			SAMPLEINDEX realSample = newSamples ? (chunk.ReadUint16BE() + 1u) : smp;
			DTMSample dtmSample;
			chunk.ReadStruct(dtmSample);
			if(realSample < 1 || realSample >= MAX_SAMPLES)
			{
				continue;
			}
			m_nSamples = std::max(m_nSamples, realSample);
			ModSample &mptSmp = Samples[realSample];
			dtmSample.ConvertToMPT(mptSmp, fileHeader.forcedSampleRate, patternFormat);
			m_szNames[realSample] = mpt::String::ReadBuf(mpt::String::maybeNullTerminated, dtmSample.name);
		}
	
		if(chunk.ReadUint16BE() == 0x0004)
		{
			// Digital Home Studio instruments
			m_nInstruments = std::min(static_cast<INSTRUMENTINDEX>(m_nSamples), static_cast<INSTRUMENTINDEX>(MAX_INSTRUMENTS - 1));

			FileReader envChunk = chunks.GetChunk(DTMChunk::idIENV);
			while(chunk.CanRead(sizeof(DTMInstrument)))
			{
				DTMInstrument instr;
				chunk.ReadStruct(instr);
				if(instr.insNum < GetNumInstruments())
				{
					ModSample &sample = Samples[instr.insNum + 1];
					sample.nVibDepth = instr.vibDepth;
					sample.nVibRate = instr.vibRate;
					sample.nVibSweep = 255;

					ModInstrument *mptIns = AllocateInstrument(instr.insNum + 1, instr.insNum + 1);
					if(mptIns != nullptr)
					{
						InstrumentEnvelope &mptEnv = mptIns->VolEnv;
						mptIns->nFadeOut = std::min(static_cast<uint16>(instr.fadeout), uint16(0xFFF));
						if(instr.envelope != 0xFF && envChunk.Seek(2 + sizeof(DTMEnvelope) * instr.envelope))
						{
							DTMEnvelope env;
							envChunk.ReadStruct(env);
							mptEnv.dwFlags.set(ENV_ENABLED);
							mptEnv.resize(std::min({ static_cast<std::size_t>(env.numPoints), std::size(env.points), static_cast<std::size_t>(MAX_ENVPOINTS) }));
							for(size_t i = 0; i < mptEnv.size(); i++)
							{
								mptEnv[i].value = std::min(uint8(64), static_cast<uint8>(env.points[i].value));
								mptEnv[i].tick = env.points[i].tick;
							}

							if(instr.sustain != 0xFF)
							{
								mptEnv.dwFlags.set(ENV_SUSTAIN);
								mptEnv.nSustainStart = mptEnv.nSustainEnd = instr.sustain;
							}
							if(!mptEnv.empty())
							{
								mptEnv.dwFlags.set(ENV_LOOP);
								mptEnv.nLoopStart = mptEnv.nLoopEnd = static_cast<uint8>(mptEnv.size() - 1);
							}
						}
					}
				}
			}
		}
	}

	// Read pattern data
	for(auto &chunk : chunks.GetAllChunks(DTMChunk::idDAPT))
	{
		chunk.Skip(4);	// FF FF FF FF
		PATTERNINDEX patNum = chunk.ReadUint16BE();
		ROWINDEX numRows = chunk.ReadUint16BE();
		if(patternFormat == DTM_206_PATTERN_FORMAT)
		{
			// The stored data is actually not row-based, but tick-based.
			numRows /= m_nDefaultSpeed;
		}
		if(!(loadFlags & loadPatternData) || patNum > 255 || !Patterns.Insert(patNum, numRows))
		{
			continue;
		}

		if(patternFormat == DTM_206_PATTERN_FORMAT)
		{
			chunk.Skip(4);
			for(CHANNELINDEX chn = 0; chn < GetNumChannels(); chn++)
			{
				uint16 length = chunk.ReadUint16BE();
				if(length % 2u) length++;
				FileReader rowChunk = chunk.ReadChunk(length);
				int tick = 0;
				std::div_t position = { 0, 0 };
				while(rowChunk.CanRead(6) && static_cast<ROWINDEX>(position.quot) < numRows)
				{
					ModCommand *m = Patterns[patNum].GetpModCommand(position.quot, chn);

					const auto [note, volume, instr, command, param, delay] = rowChunk.ReadArray<uint8, 6>();
					if(note > 0 && note <= 96)
					{
						m->note = note + NOTE_MIN + 12;
						if(position.rem)
						{
							m->command = CMD_MODCMDEX;
							m->param = 0xD0 | static_cast<ModCommand::PARAM>(std::min(position.rem, 15));
						}
					} else if(note & 0x80)
					{
						// Lower 7 bits contain note, probably intended for MIDI-like note-on/note-off events
						if(position.rem)
						{
							m->command = CMD_MODCMDEX;
							m->param = 0xC0 | static_cast<ModCommand::PARAM>(std::min(position.rem, 15));
						} else
						{
							m->note = NOTE_NOTECUT;
						}
					}
					if(volume)
					{
						m->volcmd = VOLCMD_VOLUME;
						m->vol = std::min(volume, uint8(64));  // Volume can go up to 255, but we do not support over-amplification at the moment.
					}
					if(instr)
					{
						m->instr = instr;
					}
					if(command || param)
					{
						m->command = command;
						m->param = param;
						ConvertModCommand(*m);
#ifdef MODPLUG_TRACKER
						m->Convert(MOD_TYPE_MOD, MOD_TYPE_IT, *this);
#endif
						// G is 8-bit volume
						// P is tremor (need to disable oldfx)
					}
					if(delay & 0x80)
						tick += (delay & 0x7F) * 0x100 + rowChunk.ReadUint8();
					else
						tick += delay;
					position = std::div(tick, m_nDefaultSpeed);
				}
			}
		} else
		{
			ModCommand *m = Patterns[patNum].GetpModCommand(0, 0);
			for(ROWINDEX row = 0; row < numRows; row++)
			{
				for(CHANNELINDEX chn = 0; chn < GetNumChannels(); chn++, m++)
				{
					const auto data = chunk.ReadArray<uint8, 4>();
					if(patternFormat == DTM_204_PATTERN_FORMAT)
					{
						const auto [note, instrVol, instrCmd, param] = data;
						if(note > 0 && note < 0x80)
						{
							m->note = (note >> 4) * 12 + (note & 0x0F) + NOTE_MIN + 11;
						}
						uint8 vol = instrVol >> 2;
						if(vol)
						{
							m->volcmd = VOLCMD_VOLUME;
							m->vol = vol - 1u;
						}
						m->instr = ((instrVol & 0x03) << 4) | (instrCmd >> 4);
						m->command = instrCmd & 0x0F;
						m->param = param;
					} else
					{
						ReadMODPatternEntry(data, *m);
						m->instr |= data[0] & 0x30;	// Allow more than 31 instruments
					}
					ConvertModCommand(*m);
					// Fix commands without memory and slide nibble precedence
					switch(m->command)
					{
					case CMD_PORTAMENTOUP:
					case CMD_PORTAMENTODOWN:
						if(!m->param)
						{
							m->command = CMD_NONE;
						}
						break;
					case CMD_VOLUMESLIDE:
					case CMD_TONEPORTAVOL:
					case CMD_VIBRATOVOL:
						if(m->param & 0xF0)
						{
							m->param &= 0xF0;
						} else if(!m->param)
						{
							m->command = CMD_NONE;
						}
						break;
					default:
						break;
					}
#ifdef MODPLUG_TRACKER
					m->Convert(MOD_TYPE_MOD, MOD_TYPE_IT, *this);
#endif
				}
			}
		}
	}

	// Read pattern names
	if(FileReader chunk = chunks.GetChunk(DTMChunk::idPATN))
	{
		PATTERNINDEX pat = 0;
		std::string name;
		while(chunk.CanRead(1) && pat < Patterns.Size())
		{
			chunk.ReadNullString(name, 32);
			Patterns[pat].SetName(name);
			pat++;
		}
	}

	// Read channel names
	if(FileReader chunk = chunks.GetChunk(DTMChunk::idTRKN))
	{
		CHANNELINDEX chn = 0;
		std::string name;
		while(chunk.CanRead(1) && chn < GetNumChannels())
		{
			chunk.ReadNullString(name, 32);
			ChnSettings[chn].szName = name;
			chn++;
		}
	}

	// Read sample data
	for(auto &chunk : chunks.GetAllChunks(DTMChunk::idDAIT))
	{
		SAMPLEINDEX smp = chunk.ReadUint16BE();
		if(smp >= GetNumSamples() || !(loadFlags & loadSampleData))
		{
			continue;
		}
		ModSample &mptSmp = Samples[smp + 1];
		SampleIO(
			mptSmp.uFlags[CHN_16BIT] ? SampleIO::_16bit : SampleIO::_8bit,
			mptSmp.uFlags[CHN_STEREO] ? SampleIO::stereoInterleaved: SampleIO::mono,
			SampleIO::bigEndian,
			SampleIO::signedPCM).ReadSample(mptSmp, chunk);
	}

	// Is this accurate?
	mpt::ustring tracker;
	if(patternFormat == DTM_206_PATTERN_FORMAT)
	{
		tracker = U_("Digital Home Studio");
	} else if(FileReader chunk = chunks.GetChunk(DTMChunk::idVERS))
	{
		uint32 version = chunk.ReadUint32BE();
		tracker = MPT_UFORMAT("Digital Tracker {}.{}")(version >> 4, version & 0x0F);
	} else
	{
		tracker = U_("Digital Tracker");
	}
	m_modFormat.formatName = U_("Digital Tracker");
	m_modFormat.type = U_("dtm");
	m_modFormat.madeWithTracker = std::move(tracker);
	m_modFormat.charset = mpt::Charset::Amiga_no_C1;

	return true;
}

OPENMPT_NAMESPACE_END