Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-19 00:15:54 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
20d28e80a5
winamp/Src/external_dependencies/openmpt-trunk/soundlib/Load_mdl.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

824 lines
21 KiB
C++
Raw Blame History

/*
* Load_mdl.cpp
* ------------
* Purpose: Digitrakker (MDL) module loader
* 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
// MDL file header
struct MDLFileHeader
{
char id[4]; // "DMDL"
uint8 version;
};
MPT_BINARY_STRUCT(MDLFileHeader, 5)
// RIFF-style Chunk
struct MDLChunk
{
// 16-Bit chunk identifiers
enum ChunkIdentifiers
{
idInfo = MagicLE("IN"),
idMessage = MagicLE("ME"),
idPats = MagicLE("PA"),
idPatNames = MagicLE("PN"),
idTracks = MagicLE("TR"),
idInstrs = MagicLE("II"),
idVolEnvs = MagicLE("VE"),
idPanEnvs = MagicLE("PE"),
idFreqEnvs = MagicLE("FE"),
idSampleInfo = MagicLE("IS"),
ifSampleData = MagicLE("SA"),
};
uint16le id;
uint32le length;
size_t GetLength() const
{
return length;
}
ChunkIdentifiers GetID() const
{
return static_cast<ChunkIdentifiers>(id.get());
}
};
MPT_BINARY_STRUCT(MDLChunk, 6)
struct MDLInfoBlock
{
char title[32];
char composer[20];
uint16le numOrders;
uint16le restartPos;
uint8le globalVol; // 1...255
uint8le speed; // 1...255
uint8le tempo; // 4...255
uint8le chnSetup[32];
};
MPT_BINARY_STRUCT(MDLInfoBlock, 91)
// Sample header in II block
struct MDLSampleHeader
{
uint8le smpNum;
uint8le lastNote;
uint8le volume;
uint8le volEnvFlags; // 6 bits env #, 2 bits flags
uint8le panning;
uint8le panEnvFlags;
uint16le fadeout;
uint8le vibSpeed;
uint8le vibDepth;
uint8le vibSweep;
uint8le vibType;
uint8le reserved; // zero
uint8le freqEnvFlags;
};
MPT_BINARY_STRUCT(MDLSampleHeader, 14)
struct MDLEnvelope
{
uint8 envNum;
struct
{
uint8 x; // Delta value from last point, 0 means no more points defined
uint8 y; // 0...63
} nodes[15];
uint8 flags;
uint8 loop; // Lower 4 bits = start, upper 4 bits = end
void ConvertToMPT(InstrumentEnvelope &mptEnv) const
{
mptEnv.dwFlags.reset();
mptEnv.clear();
mptEnv.reserve(15);
int16 tick = -nodes[0].x;
for(uint8 n = 0; n < 15; n++)
{
if(!nodes[n].x)
break;
tick += nodes[n].x;
mptEnv.push_back(EnvelopeNode(tick, std::min(nodes[n].y, uint8(64)))); // actually 0-63
}
mptEnv.nLoopStart = (loop & 0x0F);
mptEnv.nLoopEnd = (loop >> 4);
mptEnv.nSustainStart = mptEnv.nSustainEnd = (flags & 0x0F);
if(flags & 0x10) mptEnv.dwFlags.set(ENV_SUSTAIN);
if(flags & 0x20) mptEnv.dwFlags.set(ENV_LOOP);
}
};
MPT_BINARY_STRUCT(MDLEnvelope, 33)
struct MDLPatternHeader
{
uint8le channels;
uint8le lastRow;
char name[16];
};
MPT_BINARY_STRUCT(MDLPatternHeader, 18)
enum
{
MDLNOTE_NOTE = 1 << 0,
MDLNOTE_SAMPLE = 1 << 1,
MDLNOTE_VOLUME = 1 << 2,
MDLNOTE_EFFECTS = 1 << 3,
MDLNOTE_PARAM1 = 1 << 4,
MDLNOTE_PARAM2 = 1 << 5,
};
static constexpr VibratoType MDLVibratoType[] = { VIB_SINE, VIB_RAMP_DOWN, VIB_SQUARE, VIB_SINE };
static constexpr ModCommand::COMMAND MDLEffTrans[] =
{
/* 0 */ CMD_NONE,
/* 1st column only */
/* 1 */ CMD_PORTAMENTOUP,
/* 2 */ CMD_PORTAMENTODOWN,
/* 3 */ CMD_TONEPORTAMENTO,
/* 4 */ CMD_VIBRATO,
/* 5 */ CMD_ARPEGGIO,
/* 6 */ CMD_NONE,
/* Either column */
/* 7 */ CMD_TEMPO,
/* 8 */ CMD_PANNING8,
/* 9 */ CMD_SETENVPOSITION,
/* A */ CMD_NONE,
/* B */ CMD_POSITIONJUMP,
/* C */ CMD_GLOBALVOLUME,
/* D */ CMD_PATTERNBREAK,
/* E */ CMD_S3MCMDEX,
/* F */ CMD_SPEED,
/* 2nd column only */
/* G */ CMD_VOLUMESLIDE, // up
/* H */ CMD_VOLUMESLIDE, // down
/* I */ CMD_RETRIG,
/* J */ CMD_TREMOLO,
/* K */ CMD_TREMOR,
/* L */ CMD_NONE,
};
// receive an MDL effect, give back a 'normal' one.
static void ConvertMDLCommand(uint8 &cmd, uint8 &param)
{
if(cmd >= std::size(MDLEffTrans))
return;
uint8 origCmd = cmd;
cmd = MDLEffTrans[cmd];
switch(origCmd)
{
#ifdef MODPLUG_TRACKER
case 0x07: // Tempo
// MDL supports any nonzero tempo value, but OpenMPT doesn't
param = std::max(param, uint8(0x20));
break;
#endif // MODPLUG_TRACKER
case 0x08: // Panning
param = (param & 0x7F) * 2u;
break;
case 0x0C: // Global volume
param = (param + 1) / 2u;
break;
case 0x0D: // Pattern Break
// Convert from BCD
param = 10 * (param >> 4) + (param & 0x0F);
break;
case 0x0E: // Special
switch(param >> 4)
{
case 0x0: // unused
case 0x3: // unused
case 0x8: // Set Samplestatus (loop type)
cmd = CMD_NONE;
break;
case 0x1: // Pan Slide Left
cmd = CMD_PANNINGSLIDE;
param = (std::min(static_cast<uint8>(param & 0x0F), uint8(0x0E)) << 4) | 0x0F;
break;
case 0x2: // Pan Slide Right
cmd = CMD_PANNINGSLIDE;
param = 0xF0 | std::min(static_cast<uint8>(param & 0x0F), uint8(0x0E));
break;
case 0x4: // Vibrato Waveform
param = 0x30 | (param & 0x0F);
break;
case 0x5: // Set Finetune
cmd = CMD_FINETUNE;
param = (param << 4) ^ 0x80;
break;
case 0x6: // Pattern Loop
param = 0xB0 | (param & 0x0F);
break;
case 0x7: // Tremolo Waveform
param = 0x40 | (param & 0x0F);
break;
case 0x9: // Retrig
cmd = CMD_RETRIG;
param &= 0x0F;
break;
case 0xA: // Global vol slide up
cmd = CMD_GLOBALVOLSLIDE;
param = 0xF0 & (((param & 0x0F) + 1) << 3);
break;
case 0xB: // Global vol slide down
cmd = CMD_GLOBALVOLSLIDE;
param = ((param & 0x0F) + 1) >> 1;
break;
case 0xC: // Note cut
case 0xD: // Note delay
case 0xE: // Pattern delay
// Nothing to change here
break;
case 0xF: // Offset -- further mangled later.
cmd = CMD_OFFSET;
break;
}
break;
case 0x10: // Volslide up
if(param < 0xE0)
{
// 00...DF regular slide - four times more precise than in XM
param >>= 2;
if(param > 0x0F)
param = 0x0F;
param <<= 4;
} else if(param < 0xF0)
{
// E0...EF extra fine slide (on first tick, 4 times finer)
param = (((param & 0x0F) << 2) | 0x0F);
} else
{
// F0...FF regular fine slide (on first tick) - like in XM
param = ((param << 4) | 0x0F);
}
break;
case 0x11: // Volslide down
if(param < 0xE0)
{
// 00...DF regular slide - four times more precise than in XM
param >>= 2;
if(param > 0x0F)
param = 0x0F;
} else if(param < 0xF0)
{
// E0...EF extra fine slide (on first tick, 4 times finer)
param = (((param & 0x0F) >> 2) | 0xF0);
} else
{
// F0...FF regular fine slide (on first tick) - like in XM
}
break;
}
}
// Returns true if command was lost
static bool ImportMDLCommands(ModCommand &m, uint8 vol, uint8 e1, uint8 e2, uint8 p1, uint8 p2)
{
// Map second effect values 1-6 to effects G-L
if(e2 >= 1 && e2 <= 6)
e2 += 15;
ConvertMDLCommand(e1, p1);
ConvertMDLCommand(e2, p2);
/* From the Digitrakker documentation:
* EFx -xx - Set Sample Offset
This is a double-command. It starts the
sample at adress xxx*256.
Example: C-5 01 -- EF1 -23 ->starts sample
01 at address 12300 (in hex).
Kind of screwy, but I guess it's better than the mess required to do it with IT (which effectively
requires 3 rows in order to set the offset past 0xff00). If we had access to the entire track, we
*might* be able to shove the high offset SAy into surrounding rows (or 2x MPTM #xx), but it wouldn't
always be possible, it'd make the loader a lot uglier, and generally would be more trouble than
it'd be worth to implement.
What's more is, if there's another effect in the second column, it's ALSO processed in addition to the
offset, and the second data byte is shared between the two effects. */
uint32 offset = uint32_max;
uint8 otherCmd = CMD_NONE;
if(e1 == CMD_OFFSET)
{
// EFy -xx => offset yxx00
offset = ((p1 & 0x0F) << 8) | p2;
p1 = (p1 & 0x0F) ? 0xFF : p2;
if(e2 == CMD_OFFSET)
e2 = CMD_NONE;
else
otherCmd = e2;
} else if (e2 == CMD_OFFSET)
{
// --- EFy => offset y0000
offset = (p2 & 0x0F) << 8;
p2 = (p2 & 0x0F) ? 0xFF : 0;
otherCmd = e1;
}
if(offset != uint32_max && offset > 0xFF && ModCommand::GetEffectWeight(otherCmd) < ModCommand::GetEffectWeight(CMD_OFFSET))
{
m.command = CMD_OFFSET;
m.param = static_cast<ModCommand::PARAM>(offset & 0xFF);
m.volcmd = VOLCMD_OFFSET;
m.vol = static_cast<ModCommand::VOL>(offset >> 8);
return otherCmd != CMD_NONE || vol != 0;
}
if(vol)
{
m.volcmd = VOLCMD_VOLUME;
m.vol = (vol + 2) / 4u;
}
// If we have Dxx + G00, or Dxx + H00, combine them into Lxx/Kxx.
ModCommand::CombineEffects(e1, p1, e2, p2);
bool lostCommand = false;
// Try to fit the "best" effect into e2.
if(e1 == CMD_NONE)
{
// Easy
} else if(e2 == CMD_NONE)
{
// Almost as easy
e2 = e1;
p2 = p1;
} else if(e1 == e2 && e1 != CMD_S3MCMDEX)
{
// Digitrakker processes the effects left-to-right, so if both effects are the same, the
// second essentially overrides the first.
} else if(!vol)
{
lostCommand |= (ModCommand::TwoRegularCommandsToMPT(e1, p1, e2, p2).first != CMD_NONE);
m.volcmd = e1;
m.vol = p1;
} else
{
if(ModCommand::GetEffectWeight((ModCommand::COMMAND)e1) > ModCommand::GetEffectWeight((ModCommand::COMMAND)e2))
{
std::swap(e1, e2);
std::swap(p1, p2);
}
lostCommand = true;
}
m.command = e2;
m.param = p2;
return lostCommand;
}
static void MDLReadEnvelopes(FileReader file, std::vector<MDLEnvelope> &envelopes)
{
if(!file.CanRead(1))
return;
envelopes.resize(64);
uint8 numEnvs = file.ReadUint8();
while(numEnvs--)
{
MDLEnvelope mdlEnv;
if(!file.ReadStruct(mdlEnv) || mdlEnv.envNum > 63)
continue;
envelopes[mdlEnv.envNum] = mdlEnv;
}
}
static void CopyEnvelope(InstrumentEnvelope &mptEnv, uint8 flags, std::vector<MDLEnvelope> &envelopes)
{
uint8 envNum = flags & 0x3F;
if(envNum < envelopes.size())
envelopes[envNum].ConvertToMPT(mptEnv);
mptEnv.dwFlags.set(ENV_ENABLED, (flags & 0x80) && !mptEnv.empty());
}
static bool ValidateHeader(const MDLFileHeader &fileHeader)
{
if(std::memcmp(fileHeader.id, "DMDL", 4)
|| fileHeader.version >= 0x20)
{
return false;
}
return true;
}
CSoundFile::ProbeResult CSoundFile::ProbeFileHeaderMDL(MemoryFileReader file, const uint64 *pfilesize)
{
MDLFileHeader fileHeader;
if(!file.ReadStruct(fileHeader))
{
return ProbeWantMoreData;
}
if(!ValidateHeader(fileHeader))
{
return ProbeFailure;
}
MPT_UNREFERENCED_PARAMETER(pfilesize);
return ProbeSuccess;
}
bool CSoundFile::ReadMDL(FileReader &file, ModLoadingFlags loadFlags)
{
file.Rewind();
MDLFileHeader fileHeader;
if(!file.ReadStruct(fileHeader))
{
return false;
}
if(!ValidateHeader(fileHeader))
{
return false;
}
if(loadFlags == onlyVerifyHeader)
{
return true;
}
ChunkReader chunkFile(file);
ChunkReader::ChunkList<MDLChunk> chunks = chunkFile.ReadChunks<MDLChunk>(0);
// Read global info
FileReader chunk = chunks.GetChunk(MDLChunk::idInfo);
MDLInfoBlock info;
if(!chunk.IsValid() || !chunk.ReadStruct(info))
{
return false;
}
InitializeGlobals(MOD_TYPE_MDL);
m_SongFlags = SONG_ITCOMPATGXX;
m_playBehaviour.set(kPerChannelGlobalVolSlide);
m_playBehaviour.set(kApplyOffsetWithoutNote);
m_playBehaviour.reset(kITVibratoTremoloPanbrello);
m_playBehaviour.reset(kITSCxStopsSample); // Gate effect in underbeat.mdl
m_modFormat.formatName = U_("Digitrakker");
m_modFormat.type = U_("mdl");
m_modFormat.madeWithTracker = U_("Digitrakker ") + (
(fileHeader.version == 0x11) ? U_("3") // really could be 2.99b - close enough
: (fileHeader.version == 0x10) ? U_("2.3")
: (fileHeader.version == 0x00) ? U_("2.0 - 2.2b") // there was no 1.x release
: U_(""));
m_modFormat.charset = mpt::Charset::CP437;
m_songName = mpt::String::ReadBuf(mpt::String::spacePadded, info.title);
m_songArtist = mpt::ToUnicode(mpt::Charset::CP437, mpt::String::ReadBuf(mpt::String::spacePadded, info.composer));
m_nDefaultGlobalVolume = info.globalVol + 1;
m_nDefaultSpeed = Clamp<uint8, uint8>(info.speed, 1, 255);
m_nDefaultTempo.Set(Clamp<uint8, uint8>(info.tempo, 4, 255));
ReadOrderFromFile<uint8>(Order(), chunk, info.numOrders);
Order().SetRestartPos(info.restartPos);
m_nChannels = 0;
for(CHANNELINDEX c = 0; c < 32; c++)
{
ChnSettings[c].Reset();
ChnSettings[c].nPan = (info.chnSetup[c] & 0x7F) * 2u;
if(ChnSettings[c].nPan == 254)
ChnSettings[c].nPan = 256;
if(info.chnSetup[c] & 0x80)
ChnSettings[c].dwFlags.set(CHN_MUTE);
else
m_nChannels = c + 1;
chunk.ReadString<mpt::String::spacePadded>(ChnSettings[c].szName, 8);
}
// Read song message
chunk = chunks.GetChunk(MDLChunk::idMessage);
m_songMessage.Read(chunk, chunk.GetLength(), SongMessage::leCR);
// Read sample info and data
chunk = chunks.GetChunk(MDLChunk::idSampleInfo);
if(chunk.IsValid())
{
FileReader dataChunk = chunks.GetChunk(MDLChunk::ifSampleData);
uint8 numSamples = chunk.ReadUint8();
for(uint8 smp = 0; smp < numSamples; smp++)
{
const SAMPLEINDEX sampleIndex = chunk.ReadUint8();
if(sampleIndex == 0 || sampleIndex >= MAX_SAMPLES || !chunk.CanRead(32 + 8 + 2 + 12 + 2))
break;
if(sampleIndex > GetNumSamples())
m_nSamples = sampleIndex;
ModSample &sample = Samples[sampleIndex];
sample.Initialize();
sample.Set16BitCuePoints();
chunk.ReadString<mpt::String::spacePadded>(m_szNames[sampleIndex], 32);
chunk.ReadString<mpt::String::spacePadded>(sample.filename, 8);
uint32 c4speed;
if(fileHeader.version < 0x10)
c4speed = chunk.ReadUint16LE();
else
c4speed = chunk.ReadUint32LE();
sample.nC5Speed = c4speed * 2u;
sample.nLength = chunk.ReadUint32LE();
sample.nLoopStart = chunk.ReadUint32LE();
sample.nLoopEnd = chunk.ReadUint32LE();
if(sample.nLoopEnd != 0)
{
sample.uFlags.set(CHN_LOOP);
sample.nLoopEnd += sample.nLoopStart;
}
uint8 volume = chunk.ReadUint8();
if(fileHeader.version < 0x10)
sample.nVolume = volume;
uint8 flags = chunk.ReadUint8();
if(flags & 0x01)
{
sample.uFlags.set(CHN_16BIT);
sample.nLength /= 2u;
sample.nLoopStart /= 2u;
sample.nLoopEnd /= 2u;
}
sample.uFlags.set(CHN_PINGPONGLOOP, (flags & 0x02) != 0);
SampleIO sampleIO(
(flags & 0x01) ? SampleIO::_16bit : SampleIO::_8bit,
SampleIO::mono,
SampleIO::littleEndian,
(flags & 0x0C) ? SampleIO::MDL : SampleIO::signedPCM);
if(loadFlags & loadSampleData)
{
sampleIO.ReadSample(sample, dataChunk);
}
}
}
chunk = chunks.GetChunk(MDLChunk::idInstrs);
if(chunk.IsValid())
{
std::vector<MDLEnvelope> volEnvs, panEnvs, pitchEnvs;
MDLReadEnvelopes(chunks.GetChunk(MDLChunk::idVolEnvs), volEnvs);
MDLReadEnvelopes(chunks.GetChunk(MDLChunk::idPanEnvs), panEnvs);
MDLReadEnvelopes(chunks.GetChunk(MDLChunk::idFreqEnvs), pitchEnvs);
uint8 numInstruments = chunk.ReadUint8();
for(uint8 i = 0; i < numInstruments; i++)
{
const auto [ins, numSamples] = chunk.ReadArray<uint8, 2>();
uint8 firstNote = 0;
ModInstrument *mptIns = nullptr;
if(ins == 0
|| !chunk.CanRead(32 + sizeof(MDLSampleHeader) * numSamples)
|| (mptIns = AllocateInstrument(ins)) == nullptr)
{
chunk.Skip(32 + sizeof(MDLSampleHeader) * numSamples);
continue;
}
chunk.ReadString<mpt::String::spacePadded>(mptIns->name, 32);
for(uint8 smp = 0; smp < numSamples; smp++)
{
MDLSampleHeader sampleHeader;
chunk.ReadStruct(sampleHeader);
if(sampleHeader.smpNum == 0 || sampleHeader.smpNum > GetNumSamples())
continue;
LimitMax(sampleHeader.lastNote, static_cast<uint8>(std::size(mptIns->Keyboard)));
for(uint8 n = firstNote; n <= sampleHeader.lastNote; n++)
{
mptIns->Keyboard[n] = sampleHeader.smpNum;
}
firstNote = sampleHeader.lastNote + 1;
CopyEnvelope(mptIns->VolEnv, sampleHeader.volEnvFlags, volEnvs);
CopyEnvelope(mptIns->PanEnv, sampleHeader.panEnvFlags, panEnvs);
CopyEnvelope(mptIns->PitchEnv, sampleHeader.freqEnvFlags, pitchEnvs);
mptIns->nFadeOut = (sampleHeader.fadeout + 1u) / 2u;
#ifdef MODPLUG_TRACKER
if((mptIns->VolEnv.dwFlags & (ENV_ENABLED | ENV_LOOP)) == ENV_ENABLED)
{
// Fade-out is only supposed to happen on key-off, not at the end of a volume envelope.
// Fake it by putting a loop at the end.
mptIns->VolEnv.nLoopStart = mptIns->VolEnv.nLoopEnd = static_cast<uint8>(mptIns->VolEnv.size() - 1);
mptIns->VolEnv.dwFlags.set(ENV_LOOP);
}
for(auto &p : mptIns->PitchEnv)
{
// Scale pitch envelope
p.value = (p.value * 6u) / 16u;
}
#endif // MODPLUG_TRACKER
// Samples were already initialized above. Let's hope they are not going to be re-used with different volume / panning / vibrato...
ModSample &mptSmp = Samples[sampleHeader.smpNum];
// This flag literally enables and disables the default volume of a sample. If you disable this flag,
// the sample volume of a previously sample is re-used, even if you put an instrument number next to the note.
if(sampleHeader.volEnvFlags & 0x40)
mptSmp.nVolume = sampleHeader.volume;
else
mptSmp.uFlags.set(SMP_NODEFAULTVOLUME);
mptSmp.nPan = std::min(static_cast<uint16>(sampleHeader.panning * 2), uint16(254));
mptSmp.nVibType = MDLVibratoType[sampleHeader.vibType & 3];
mptSmp.nVibSweep = sampleHeader.vibSweep;
mptSmp.nVibDepth = (sampleHeader.vibDepth + 3u) / 4u;
mptSmp.nVibRate = sampleHeader.vibSpeed;
// Convert to IT-like vibrato sweep
if(mptSmp.nVibSweep != 0)
mptSmp.nVibSweep = mpt::saturate_cast<decltype(mptSmp.nVibSweep)>(Util::muldivr_unsigned(mptSmp.nVibDepth, 256, mptSmp.nVibSweep));
else
mptSmp.nVibSweep = 255;
if(sampleHeader.panEnvFlags & 0x40)
mptSmp.uFlags.set(CHN_PANNING);
}
}
}
// Read pattern tracks
std::vector<FileReader> tracks;
if((loadFlags & loadPatternData) && (chunk = chunks.GetChunk(MDLChunk::idTracks)).IsValid())
{
uint32 numTracks = chunk.ReadUint16LE();
tracks.resize(numTracks + 1);
for(uint32 i = 1; i <= numTracks; i++)
{
tracks[i] = chunk.ReadChunk(chunk.ReadUint16LE());
}
}
// Read actual patterns
if((loadFlags & loadPatternData) && (chunk = chunks.GetChunk(MDLChunk::idPats)).IsValid())
{
PATTERNINDEX numPats = chunk.ReadUint8();
// In case any muted channels contain data, be sure that we import them as well.
for(PATTERNINDEX pat = 0; pat < numPats; pat++)
{
CHANNELINDEX numChans = 32;
if(fileHeader.version >= 0x10)
{
MDLPatternHeader patHead;
chunk.ReadStruct(patHead);
if(patHead.channels > m_nChannels && patHead.channels <= 32)
m_nChannels = patHead.channels;
numChans = patHead.channels;
}
for(CHANNELINDEX chn = 0; chn < numChans; chn++)
{
if(chunk.ReadUint16LE() > 0 && chn >= m_nChannels && chn < 32)
m_nChannels = chn + 1;
}
}
chunk.Seek(1);
Patterns.ResizeArray(numPats);
for(PATTERNINDEX pat = 0; pat < numPats; pat++)
{
CHANNELINDEX numChans = 32;
ROWINDEX numRows = 64;
std::string name;
if(fileHeader.version >= 0x10)
{
MDLPatternHeader patHead;
chunk.ReadStruct(patHead);
numChans = patHead.channels;
numRows = patHead.lastRow + 1;
name = mpt::String::ReadBuf(mpt::String::spacePadded, patHead.name);
}
if(!Patterns.Insert(pat, numRows))
{
chunk.Skip(2 * numChans);
continue;
}
Patterns[pat].SetName(name);
for(CHANNELINDEX chn = 0; chn < numChans; chn++)
{
uint16 trkNum = chunk.ReadUint16LE();
if(!trkNum || trkNum >= tracks.size() || chn >= m_nChannels)
continue;
FileReader &track = tracks[trkNum];
track.Rewind();
ROWINDEX row = 0;
while(row < numRows && track.CanRead(1))
{
ModCommand *m = Patterns[pat].GetpModCommand(row, chn);
uint8 b = track.ReadUint8();
uint8 x = (b >> 2), y = (b & 3);
switch(y)
{
case 0:
// (x + 1) empty notes follow
row += x + 1;
break;
case 1:
// Repeat previous note (x + 1) times
if(row > 0)
{
ModCommand &orig = *Patterns[pat].GetpModCommand(row - 1, chn);
do
{
*m = orig;
m += m_nChannels;
row++;
} while (row < numRows && x--);
}
break;
case 2:
// Copy note from row x
if(row > x)
{
*m = *Patterns[pat].GetpModCommand(x, chn);
}
row++;
break;
case 3:
// New note data
if(x & MDLNOTE_NOTE)
{
b = track.ReadUint8();
m->note = (b > 120) ? static_cast<ModCommand::NOTE>(NOTE_KEYOFF) : static_cast<ModCommand::NOTE>(b);
}
if(x & MDLNOTE_SAMPLE)
{
m->instr = track.ReadUint8();
}
{
uint8 vol = 0, e1 = 0, e2 = 0, p1 = 0, p2 = 0;
if(x & MDLNOTE_VOLUME)
{
vol = track.ReadUint8();
}
if(x & MDLNOTE_EFFECTS)
{
b = track.ReadUint8();
e1 = (b & 0x0F);
e2 = (b >> 4);
}
if(x & MDLNOTE_PARAM1)
p1 = track.ReadUint8();
if(x & MDLNOTE_PARAM2)
p2 = track.ReadUint8();
ImportMDLCommands(*m, vol, e1, e2, p1, p2);
}
row++;
break;
}
}
}
}
}
if((loadFlags & loadPatternData) && (chunk = chunks.GetChunk(MDLChunk::idPatNames)).IsValid())
{
PATTERNINDEX i = 0;
while(i < Patterns.Size() && chunk.CanRead(16))
{
char name[17];
chunk.ReadString<mpt::String::spacePadded>(name, 16);
Patterns[i].SetName(name);
}
}
return true;
}
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink