608 lines
16 KiB
C++
608 lines
16 KiB
C++
/*
|
|
* 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
|