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

/*
 * Load_mtm.cpp
 * ------------
 * Purpose: MTM (MultiTracker) module loader
 * Notes  : (currently none)
 * Authors: Olivier Lapicque
 *          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

// File Header
struct MTMFileHeader
{
	char     id[3];          // MTM file marker
	uint8le  version;        // Tracker version
	char     songName[20];   // ASCIIZ songname
	uint16le numTracks;      // Number of tracks saved
	uint8le  lastPattern;    // Last pattern number saved
	uint8le  lastOrder;      // Last order number to play (songlength-1)
	uint16le commentSize;    // Length of comment field
	uint8le  numSamples;     // Number of samples saved
	uint8le  attribute;      // Attribute byte (unused)
	uint8le  beatsPerTrack;  // Numbers of rows in every pattern (MultiTracker itself does not seem to support values != 64)
	uint8le  numChannels;    // Number of channels used
	uint8le  panPos[32];     // Channel pan positions
};

MPT_BINARY_STRUCT(MTMFileHeader, 66)


// Sample Header
struct MTMSampleHeader
{
	char     samplename[22];
	uint32le length;
	uint32le loopStart;
	uint32le loopEnd;
	int8le   finetune;
	uint8le  volume;
	uint8le  attribute;

	// Convert an MTM sample header to OpenMPT's internal sample header.
	void ConvertToMPT(ModSample &mptSmp) const
	{
		mptSmp.Initialize();
		mptSmp.nVolume = std::min(uint16(volume * 4), uint16(256));
		if(length > 2)
		{
			mptSmp.nLength = length;
			mptSmp.nLoopStart = loopStart;
			mptSmp.nLoopEnd = std::max(loopEnd.get(), uint32(1)) - 1;
			LimitMax(mptSmp.nLoopEnd, mptSmp.nLength);
			if(mptSmp.nLoopStart + 4 >= mptSmp.nLoopEnd)
				mptSmp.nLoopStart = mptSmp.nLoopEnd = 0;
			if(mptSmp.nLoopEnd > 2)
				mptSmp.uFlags.set(CHN_LOOP);
			mptSmp.nFineTune = finetune; // Uses MOD units but allows the full int8 range rather than just -8...+7 so we keep the value as-is and convert it during playback
			mptSmp.nC5Speed = ModSample::TransposeToFrequency(0, finetune * 16);

			if(attribute & 0x01)
			{
				mptSmp.uFlags.set(CHN_16BIT);
				mptSmp.nLength /= 2;
				mptSmp.nLoopStart /= 2;
				mptSmp.nLoopEnd /= 2;
			}
		}
	}
};

MPT_BINARY_STRUCT(MTMSampleHeader, 37)


static bool ValidateHeader(const MTMFileHeader &fileHeader)
{
	if(std::memcmp(fileHeader.id, "MTM", 3)
		|| fileHeader.version >= 0x20
		|| fileHeader.lastOrder > 127
		|| fileHeader.beatsPerTrack > 64
		|| fileHeader.numChannels > 32
		|| fileHeader.numChannels == 0
		)
	{
		return false;
	}
	return true;
}


static uint64 GetHeaderMinimumAdditionalSize(const MTMFileHeader &fileHeader)
{
	return sizeof(MTMSampleHeader) * fileHeader.numSamples + 128 + 192 * fileHeader.numTracks + 64 * (fileHeader.lastPattern + 1) + fileHeader.commentSize;
}


CSoundFile::ProbeResult CSoundFile::ProbeFileHeaderMTM(MemoryFileReader file, const uint64 *pfilesize)
{
	MTMFileHeader fileHeader;
	if(!file.ReadStruct(fileHeader))
	{
		return ProbeWantMoreData;
	}
	if(!ValidateHeader(fileHeader))
	{
		return ProbeFailure;
	}
	return ProbeAdditionalSize(file, pfilesize, GetHeaderMinimumAdditionalSize(fileHeader));
}


bool CSoundFile::ReadMTM(FileReader &file, ModLoadingFlags loadFlags)
{
	file.Rewind();
	MTMFileHeader fileHeader;
	if(!file.ReadStruct(fileHeader))
	{
		return false;
	}
	if(!ValidateHeader(fileHeader))
	{
		return false;
	}
	if(!file.CanRead(mpt::saturate_cast<FileReader::off_t>(GetHeaderMinimumAdditionalSize(fileHeader))))
	{
		return false;
	}
	if(loadFlags == onlyVerifyHeader)
	{
		return true;
	}

	InitializeGlobals(MOD_TYPE_MTM);
	m_songName = mpt::String::ReadBuf(mpt::String::maybeNullTerminated, fileHeader.songName);
	m_nSamples = fileHeader.numSamples;
	m_nChannels = fileHeader.numChannels;
	
	m_modFormat.formatName = U_("MultiTracker");
	m_modFormat.type = U_("mtm");
	m_modFormat.madeWithTracker = MPT_UFORMAT("MultiTracker {}.{}")(fileHeader.version >> 4, fileHeader.version & 0x0F);
	m_modFormat.charset = mpt::Charset::CP437;

	// Reading instruments
	for(SAMPLEINDEX smp = 1; smp <= GetNumSamples(); smp++)
	{
		MTMSampleHeader sampleHeader;
		file.ReadStruct(sampleHeader);
		sampleHeader.ConvertToMPT(Samples[smp]);
		m_szNames[smp] = mpt::String::ReadBuf(mpt::String::maybeNullTerminated, sampleHeader.samplename);
	}

	// Setting Channel Pan Position
	for(CHANNELINDEX chn = 0; chn < GetNumChannels(); chn++)
	{
		ChnSettings[chn].Reset();
		ChnSettings[chn].nPan = ((fileHeader.panPos[chn] & 0x0F) << 4) + 8;
	}

	// Reading pattern order
	uint8 orders[128];
	file.ReadArray(orders);
	ReadOrderFromArray(Order(), orders, fileHeader.lastOrder + 1, 0xFF, 0xFE);

	// Reading Patterns
	const ROWINDEX rowsPerPat = fileHeader.beatsPerTrack ? fileHeader.beatsPerTrack : 64;
	FileReader tracks = file.ReadChunk(192 * fileHeader.numTracks);

	if(loadFlags & loadPatternData)
		Patterns.ResizeArray(fileHeader.lastPattern + 1);

	bool hasSpeed = false, hasTempo = false;
	for(PATTERNINDEX pat = 0; pat <= fileHeader.lastPattern; pat++)
	{
		if(!(loadFlags & loadPatternData) || !Patterns.Insert(pat, rowsPerPat))
		{
			file.Skip(64);
			continue;
		}

		for(CHANNELINDEX chn = 0; chn < 32; chn++)
		{
			uint16 track = file.ReadUint16LE();
			if(track == 0 || track > fileHeader.numTracks || chn >= GetNumChannels())
			{
				continue;
			}

			tracks.Seek(192 * (track - 1));

			ModCommand *m = Patterns[pat].GetpModCommand(0, chn);
			for(ROWINDEX row = 0; row < rowsPerPat; row++, m += GetNumChannels())
			{
				const auto [noteInstr, instrCmd, par] = tracks.ReadArray<uint8, 3>();

				if(noteInstr & 0xFC)
					m->note = (noteInstr >> 2) + 36 + NOTE_MIN;
				m->instr = ((noteInstr & 0x03) << 4) | (instrCmd >> 4);
				uint8 cmd = instrCmd & 0x0F;
				uint8 param = par;
				if(cmd == 0x0A)
				{
					if(param & 0xF0) param &= 0xF0; else param &= 0x0F;
				} else if(cmd == 0x08)
				{
					// No 8xx panning in MultiTracker, only E8x
					cmd = param = 0;
				} else if(cmd == 0x0E)
				{
					// MultiTracker does not support these commands
					switch(param & 0xF0)
					{
					case 0x00:
					case 0x30:
					case 0x40:
					case 0x60:
					case 0x70:
					case 0xF0:
						cmd = param = 0;
						break;
					}
				}
				if(cmd != 0 || param != 0)
				{
					m->command = cmd;
					m->param = param;
					ConvertModCommand(*m);
#ifdef MODPLUG_TRACKER
					m->Convert(MOD_TYPE_MTM, MOD_TYPE_S3M, *this);
#endif
					if(m->command == CMD_SPEED)
						hasSpeed = true;
					else if(m->command == CMD_TEMPO)
						hasTempo = true;
				}
			}
		}
	}

	// Curiously, speed commands reset the tempo to 125 in MultiTracker, and tempo commands reset the speed to 6.
	// External players of the time (e.g. DMP) did not implement this quirk and assumed a more ProTracker-like interpretation of speed and tempo.
	// Quite a few musicians created MTMs that make use DMP's speed and tempo interpretation, which in return means that they will play too
	// fast or too slow in MultiTracker. On the other hand there are also a few MTMs that break when using ProTracker-like speed and tempo.
	// As a way to support as many modules of both types as possible, we will assume a ProTracker-like interpretation if both speed and tempo
	// commands are found on the same line, and a MultiTracker-like interpretation when they are never found on the same line.
	if(hasSpeed && hasTempo)
	{
		bool hasSpeedAndTempoOnSameRow = false;
		for(const auto &pattern : Patterns)
		{
			for(ROWINDEX row = 0; row < pattern.GetNumRows(); row++)
			{
				const auto rowBase = pattern.GetRow(row);
				bool hasSpeedOnRow = false, hasTempoOnRow = false;
				for(CHANNELINDEX chn = 0; chn < GetNumChannels(); chn++)
				{
					if(rowBase[chn].command == CMD_SPEED)
						hasSpeedOnRow = true;
					else if(rowBase[chn].command == CMD_TEMPO)
						hasTempoOnRow = true;
				}
				if(hasSpeedOnRow && hasTempoOnRow)
				{
					hasSpeedAndTempoOnSameRow = true;
					break;
				}
			}
			if(hasSpeedAndTempoOnSameRow)
				break;
		}

		if(!hasSpeedAndTempoOnSameRow)
		{
			for(auto &pattern : Patterns)
			{
				for(ROWINDEX row = 0; row < pattern.GetNumRows(); row++)
				{
					const auto rowBase = pattern.GetRow(row);
					for(CHANNELINDEX chn = 0; chn < GetNumChannels(); chn++)
					{
						if(rowBase[chn].command == CMD_SPEED || rowBase[chn].command == CMD_TEMPO)
						{
							const bool writeTempo = rowBase[chn].command == CMD_SPEED;
							pattern.WriteEffect(EffectWriter(writeTempo ? CMD_TEMPO : CMD_SPEED, writeTempo ? 125 : 6).Row(row));
							break;
						}
					}
				}
			}
		}
	}

	if(fileHeader.commentSize != 0)
	{
		// Read message with a fixed line length of 40 characters
		// (actually the last character is always null, so make that 39 + 1 padding byte)
		m_songMessage.ReadFixedLineLength(file, fileHeader.commentSize, 39, 1);
	}

	// Reading Samples
	if(loadFlags & loadSampleData)
	{
		for(SAMPLEINDEX smp = 1; smp <= GetNumSamples(); smp++)
		{
			SampleIO(
				Samples[smp].uFlags[CHN_16BIT] ? SampleIO::_16bit : SampleIO::_8bit,
				SampleIO::mono,
				SampleIO::littleEndian,
				SampleIO::unsignedPCM)
				.ReadSample(Samples[smp], file);
		}
	}

	m_nMinPeriod = 64;
	m_nMaxPeriod = 32767;
	return true;
}


OPENMPT_NAMESPACE_END