amy/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-12 10:41:01 -05:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions
winamp/Src/external_dependencies/openmpt-trunk/soundlib/Load_dmf.cpp
Jef f2d940131e Initial community commit
2024-09-24 14:54:57 +02:00

1148 lines
35 KiB
C++
Raw Blame History

/*
* load_dmf.cpp
* ------------
* Purpose: DMF module loader (X-Tracker by D-LUSiON).
* Notes : If it wasn't already outdated when the tracker left beta state, this would be a rather interesting
* and in some parts even sophisticated format - effect columns are separated by effect type, an easy to
* understand BPM tempo mode, effect durations are always divided into a 256th row, vibrato effects are
* specified by period length and the same 8-Bit granularity is used for both volume and panning.
* Unluckily, this format does not offer any envelopes or multi-sample instruments, and bidi sample loops
* are missing as well, so it was already well behind FT2 back then.
* Authors: Johannes Schultz (mostly based on DMF.TXT, DMF_EFFC.TXT, trial and error and some invaluable hints by Zatzen)
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Loaders.h"
#include "BitReader.h"
OPENMPT_NAMESPACE_BEGIN
// DMF header
struct DMFFileHeader
{
char signature[4]; // "DDMF"
uint8 version; // 1 - 7 are beta versions, 8 is the official thing, 10 is xtracker32
char tracker[8]; // "XTRACKER"
char songname[30];
char composer[20];
uint8 creationDay;
uint8 creationMonth;
uint8 creationYear;
};
MPT_BINARY_STRUCT(DMFFileHeader, 66)
struct DMFChunk
{
// 32-Bit chunk identifiers
enum ChunkIdentifiers
{
idCMSG = MagicLE("CMSG"), // Song message
idSEQU = MagicLE("SEQU"), // Order list
idPATT = MagicLE("PATT"), // Patterns
idSMPI = MagicLE("SMPI"), // Sample headers
idSMPD = MagicLE("SMPD"), // Sample data
idSMPJ = MagicLE("SMPJ"), // Sample jump table (XTracker 32 only)
idENDE = MagicLE("ENDE"), // Last four bytes of DMF file
idSETT = MagicLE("SETT"), // Probably contains GUI settings
};
uint32le id;
uint32le length;
size_t GetLength() const
{
return length;
}
ChunkIdentifiers GetID() const
{
return static_cast<ChunkIdentifiers>(id.get());
}
};
MPT_BINARY_STRUCT(DMFChunk, 8)
// Pattern header (global)
struct DMFPatterns
{
uint16le numPatterns; // 1..1024 patterns
uint8le numTracks; // 1..32 channels
};
MPT_BINARY_STRUCT(DMFPatterns, 3)
// Pattern header (for each pattern)
struct DMFPatternHeader
{
uint8le numTracks; // 1..32 channels
uint8le beat; // [hi|lo] -> hi = rows per beat, lo = reserved
uint16le numRows;
uint32le patternLength;
// patttern data follows here ...
};
MPT_BINARY_STRUCT(DMFPatternHeader, 8)
// Sample header
struct DMFSampleHeader
{
enum SampleFlags
{
// Sample flags
smpLoop = 0x01,
smp16Bit = 0x02,
smpCompMask = 0x0C,
smpComp1 = 0x04, // Compression type 1
smpComp2 = 0x08, // Compression type 2 (unused)
smpComp3 = 0x0C, // Compression type 3 (ditto)
smpLibrary = 0x80, // Sample is stored in a library
};
uint32le length;
uint32le loopStart;
uint32le loopEnd;
uint16le c3freq; // 1000..45000hz
uint8le volume; // 0 = ignore
uint8le flags;
// Convert an DMFSampleHeader to OpenMPT's internal sample representation.
void ConvertToMPT(ModSample &mptSmp) const
{
mptSmp.Initialize();
mptSmp.nLength = length;
mptSmp.nSustainStart = loopStart;
mptSmp.nSustainEnd = loopEnd;
mptSmp.nC5Speed = c3freq;
mptSmp.nGlobalVol = 64;
if(volume)
mptSmp.nVolume = volume + 1;
else
mptSmp.nVolume = 256;
mptSmp.uFlags.set(SMP_NODEFAULTVOLUME, volume == 0);
if((flags & smpLoop) != 0 && mptSmp.nSustainEnd > mptSmp.nSustainStart)
{
mptSmp.uFlags.set(CHN_SUSTAINLOOP);
}
if((flags & smp16Bit) != 0)
{
mptSmp.uFlags.set(CHN_16BIT);
mptSmp.nLength /= 2;
mptSmp.nSustainStart /= 2;
mptSmp.nSustainEnd /= 2;
}
}
};
MPT_BINARY_STRUCT(DMFSampleHeader, 16)
// Pattern translation memory
struct DMFPatternSettings
{
struct ChannelState
{
ModCommand::NOTE noteBuffer = NOTE_NONE; // Note buffer
ModCommand::NOTE lastNote = NOTE_NONE; // Last played note on channel
uint8 vibratoType = 8; // Last used vibrato type on channel
uint8 tremoloType = 4; // Last used tremolo type on channel
uint8 highOffset = 6; // Last used high offset on channel
bool playDir = false; // Sample play direction... false = forward (default)
};
std::vector<ChannelState> channels; // Memory for each channel's state
bool realBPMmode = false; // true = BPM mode
uint8 beat = 0; // Rows per beat
uint8 tempoTicks = 32; // Tick mode param
uint8 tempoBPM = 120; // BPM mode param
uint8 internalTicks = 6; // Ticks per row in final pattern
DMFPatternSettings(CHANNELINDEX numChannels)
: channels(numChannels)
{ }
};
// Convert portamento value (not very accurate due to X-Tracker's higher granularity, to say the least)
static uint8 DMFporta2MPT(uint8 val, const uint8 internalTicks, const bool hasFine)
{
if(val == 0)
return 0;
else if((val <= 0x0F && hasFine) || internalTicks < 2)
return (val | 0xF0);
else
return std::max(uint8(1), static_cast<uint8>((val / (internalTicks - 1)))); // no porta on first tick!
}
// Convert portamento / volume slide value (not very accurate due to X-Tracker's higher granularity, to say the least)
static uint8 DMFslide2MPT(uint8 val, const uint8 internalTicks, const bool up)
{
val = std::max(uint8(1), static_cast<uint8>(val / 4));
const bool isFine = (val < 0x0F) || (internalTicks < 2);
if(!isFine)
val = std::max(uint8(1), static_cast<uint8>((val + internalTicks - 2) / (internalTicks - 1))); // no slides on first tick! "+ internalTicks - 2" for rounding precision
if(up)
return (isFine ? 0x0F : 0x00) | (val << 4);
else
return (isFine ? 0xF0 : 0x00) | (val & 0x0F);
}
// Calculate tremor on/off param
static uint8 DMFtremor2MPT(uint8 val, const uint8 internalTicks)
{
uint8 ontime = (val >> 4);
uint8 offtime = (val & 0x0F);
ontime = static_cast<uint8>(Clamp(ontime * internalTicks / 15, 1, 15));
offtime = static_cast<uint8>(Clamp(offtime * internalTicks / 15, 1, 15));
return (ontime << 4) | offtime;
}
// Calculate delay parameter for note cuts / delays
static uint8 DMFdelay2MPT(uint8 val, const uint8 internalTicks)
{
int newval = (int)val * (int)internalTicks / 255;
Limit(newval, 0, 15);
return (uint8)newval;
}
// Convert vibrato-style command parameters
static uint8 DMFvibrato2MPT(uint8 val, const uint8 internalTicks)
{
// MPT: 1 vibrato period == 64 ticks... we have internalTicks ticks per row.
// X-Tracker: Period length specified in rows!
const int periodInTicks = std::max(1, (val >> 4)) * internalTicks;
const uint8 matchingPeriod = static_cast<uint8>(Clamp((128 / periodInTicks), 1, 15));
return (matchingPeriod << 4) | std::max(uint8(1), static_cast<uint8>(val & 0x0F));
}
// Try using effect memory (zero paramer) to give the effect swapper some optimization hints.
static void ApplyEffectMemory(const ModCommand *m, ROWINDEX row, CHANNELINDEX numChannels, uint8 effect, uint8 &param)
{
if(effect == CMD_NONE || param == 0)
return;
const bool isTonePortaEffect = (effect == CMD_PORTAMENTOUP || effect == CMD_PORTAMENTODOWN || effect == CMD_TONEPORTAMENTO);
const bool isVolSlideEffect = (effect == CMD_VOLUMESLIDE || effect == CMD_TONEPORTAVOL || effect == CMD_VIBRATOVOL);
while(row > 0)
{
m -= numChannels;
row--;
// First, keep some extra rules in mind for portamento, where effect memory is shared between various commands.
bool isSame = (effect == m->command);
if(isTonePortaEffect && (m->command == CMD_PORTAMENTOUP || m->command == CMD_PORTAMENTODOWN || m->command == CMD_TONEPORTAMENTO))
{
if(m->param < 0xE0)
{
// Avoid effect param for fine slides, or else we could accidentally put this command in the volume column, where fine slides won't work!
isSame = true;
} else
{
return;
}
} else if(isVolSlideEffect && (m->command == CMD_VOLUMESLIDE || m->command == CMD_TONEPORTAVOL || m->command == CMD_VIBRATOVOL))
{
isSame = true;
}
if(isTonePortaEffect
&& (m->volcmd == VOLCMD_PORTAUP || m->volcmd == VOLCMD_PORTADOWN || m->volcmd == VOLCMD_TONEPORTAMENTO)
&& m->vol != 0)
{
// Uuh... Don't even try
return;
} else if(isVolSlideEffect
&& (m->volcmd == VOLCMD_FINEVOLUP || m->volcmd == VOLCMD_FINEVOLDOWN || m->volcmd == VOLCMD_VOLSLIDEUP || m->volcmd == VOLCMD_VOLSLIDEDOWN)
&& m->vol != 0)
{
// Same!
return;
}
if(isSame)
{
if(param != m->param && m->param != 0)
{
// No way to optimize this
return;
} else if(param == m->param)
{
// Yay!
param = 0;
return;
}
}
}
}
static PATTERNINDEX ConvertDMFPattern(FileReader &file, const uint8 fileVersion, DMFPatternSettings &settings, CSoundFile &sndFile)
{
// Pattern flags
enum PatternFlags
{
// Global Track
patGlobPack = 0x80, // Pack information for global track follows
patGlobMask = 0x3F, // Mask for global effects
// Note tracks
patCounter = 0x80, // Pack information for current channel follows
patInstr = 0x40, // Instrument number present
patNote = 0x20, // Note present
patVolume = 0x10, // Volume present
patInsEff = 0x08, // Instrument effect present
patNoteEff = 0x04, // Note effect present
patVolEff = 0x02, // Volume effect stored
};
file.Rewind();
DMFPatternHeader patHead;
if(fileVersion < 3)
{
patHead.numTracks = file.ReadUint8();
file.Skip(2); // not sure what this is, later X-Tracker versions just skip over it
patHead.numRows = file.ReadUint16LE();
patHead.patternLength = file.ReadUint32LE();
} else
{
file.ReadStruct(patHead);
}
if(fileVersion < 6)
patHead.beat = 0;
const ROWINDEX numRows = Clamp(ROWINDEX(patHead.numRows), ROWINDEX(1), MAX_PATTERN_ROWS);
const PATTERNINDEX pat = sndFile.Patterns.InsertAny(numRows);
if(pat == PATTERNINDEX_INVALID)
{
return pat;
}
PatternRow m = sndFile.Patterns[pat].GetRow(0);
const CHANNELINDEX numChannels = std::min(static_cast<CHANNELINDEX>(sndFile.GetNumChannels() - 1), static_cast<CHANNELINDEX>(patHead.numTracks));
// When breaking to a pattern with less channels that the previous pattern,
// all voices in the now unused channels are killed:
for(CHANNELINDEX chn = numChannels + 1; chn < sndFile.GetNumChannels(); chn++)
{
m[chn].note = NOTE_NOTECUT;
}
// Initialize tempo stuff
settings.beat = (patHead.beat >> 4);
bool tempoChange = settings.realBPMmode;
uint8 writeDelay = 0;
// Counters for channel packing (including global track)
std::vector<uint8> channelCounter(numChannels + 1, 0);
for(ROWINDEX row = 0; row < numRows; row++)
{
// Global track info counter reached 0 => read global track data
if(channelCounter[0] == 0)
{
uint8 globalInfo = file.ReadUint8();
// 0x80: Packing counter (if not present, counter stays at 0)
if((globalInfo & patGlobPack) != 0)
{
channelCounter[0] = file.ReadUint8();
}
globalInfo &= patGlobMask;
uint8 globalData = 0;
if(globalInfo != 0)
{
globalData = file.ReadUint8();
}
switch(globalInfo)
{
case 1: // Set Tick Frame Speed
settings.realBPMmode = false;
settings.tempoTicks = std::max(uint8(1), globalData); // Tempo in 1/4 rows per second
settings.tempoBPM = 0; // Automatically updated by X-Tracker
tempoChange = true;
break;
case 2: // Set BPM Speed (real BPM mode)
if(globalData) // DATA = 0 doesn't do anything
{
settings.realBPMmode = true;
settings.tempoBPM = globalData; // Tempo in real BPM (depends on rows per beat)
if(settings.beat != 0)
{
settings.tempoTicks = (globalData * settings.beat * 15); // Automatically updated by X-Tracker
}
tempoChange = true;
}
break;
case 3: // Set Beat
settings.beat = (globalData >> 4);
if(settings.beat != 0)
{
// Tempo changes only if we're in real BPM mode
tempoChange = settings.realBPMmode;
} else
{
// If beat is 0, change to tick speed mode, but keep current tempo
settings.realBPMmode = false;
}
break;
case 4: // Tick Delay
writeDelay = globalData;
break;
case 5: // Set External Flag
break;
case 6: // Slide Speed Up
if(globalData > 0)
{
uint8 &tempoData = (settings.realBPMmode) ? settings.tempoBPM : settings.tempoTicks;
if(tempoData < 256 - globalData)
{
tempoData += globalData;
} else
{
tempoData = 255;
}
tempoChange = true;
}
break;
case 7: // Slide Speed Down
if(globalData > 0)
{
uint8 &tempoData = (settings.realBPMmode) ? settings.tempoBPM : settings.tempoTicks;
if(tempoData > 1 + globalData)
{
tempoData -= globalData;
} else
{
tempoData = 1;
}
tempoChange = true;
}
break;
}
} else
{
channelCounter[0]--;
}
// These will eventually be written to the pattern
int speed = 0, tempo = 0;
if(tempoChange)
{
// Can't do anything if we're in BPM mode and there's no rows per beat set...
if(!settings.realBPMmode || settings.beat)
{
// My approach to convert X-Tracker's "tick speed" (1/4 rows per second):
// Tempo * 6 / Speed = Beats per Minute
// => Tempo * 6 / (Speed * 60) = Beats per Second
// => Tempo * 24 / (Speed * 60) = Rows per Second (4 rows per beat at tempo 6)
// => Tempo = 60 * Rows per Second * Speed / 24
// For some reason, using settings.tempoTicks + 1 gives more accurate results than just settings.tempoTicks... (same problem in the old libmodplug DMF loader)
// Original unoptimized formula:
//const int tickspeed = (tempoRealBPMmode) ? std::max(1, (tempoData * beat * 4) / 60) : tempoData;
const int tickspeed = (settings.realBPMmode) ? std::max(1, settings.tempoBPM * settings.beat * 2) : ((settings.tempoTicks + 1) * 30);
// Try to find matching speed - try higher speeds first, so that effects like arpeggio and tremor work better.
for(speed = 255; speed >= 1; speed--)
{
// Original unoptimized formula:
// tempo = 30 * tickspeed * speed / 48;
tempo = tickspeed * speed / 48;
if(tempo >= 32 && tempo <= 255)
break;
}
Limit(tempo, 32, 255);
settings.internalTicks = static_cast<uint8>(std::max(1, speed));
} else
{
tempoChange = false;
}
}
m = sndFile.Patterns[pat].GetpModCommand(row, 1); // Reserve first channel for global effects
for(CHANNELINDEX chn = 1; chn <= numChannels; chn++, m++)
{
// Track info counter reached 0 => read track data
if(channelCounter[chn] == 0)
{
const uint8 channelInfo = file.ReadUint8();
////////////////////////////////////////////////////////////////
// 0x80: Packing counter (if not present, counter stays at 0)
if((channelInfo & patCounter) != 0)
{
channelCounter[chn] = file.ReadUint8();
}
////////////////////////////////////////////////////////////////
// 0x40: Instrument
bool slideNote = true; // If there is no instrument number next to a note, the note is not retriggered!
if((channelInfo & patInstr) != 0)
{
m->instr = file.ReadUint8();
if(m->instr != 0)
{
slideNote = false;
}
}
////////////////////////////////////////////////////////////////
// 0x20: Note
if((channelInfo & patNote) != 0)
{
m->note = file.ReadUint8();
if(m->note >= 1 && m->note <= 108)
{
m->note = static_cast<uint8>(Clamp(m->note + 24, NOTE_MIN, NOTE_MAX));
settings.channels[chn].lastNote = m->note;
} else if(m->note >= 129 && m->note <= 236)
{
// "Buffer notes" for portamento (and other effects?) that are actually not played, but just "queued"...
m->note = static_cast<uint8>(Clamp((m->note & 0x7F) + 24, NOTE_MIN, NOTE_MAX));
settings.channels[chn].noteBuffer = m->note;
m->note = NOTE_NONE;
} else if(m->note == 255)
{
m->note = NOTE_NOTECUT;
}
}
// If there's just an instrument number, but no note, retrigger sample.
if(m->note == NOTE_NONE && m->instr > 0)
{
m->note = settings.channels[chn].lastNote;
m->instr = 0;
}
if(m->IsNote())
{
settings.channels[chn].playDir = false;
}
uint8 effect1 = CMD_NONE, effect2 = CMD_NONE, effect3 = CMD_NONE;
uint8 effectParam1 = 0, effectParam2 = 0, effectParam3 = 0;
bool useMem2 = false, useMem3 = false; // Effect can use memory if necessary
////////////////////////////////////////////////////////////////
// 0x10: Volume
if((channelInfo & patVolume) != 0)
{
m->volcmd = VOLCMD_VOLUME;
m->vol = (file.ReadUint8() + 2) / 4; // Should be + 3 instead of + 2, but volume 1 is silent in X-Tracker.
}
////////////////////////////////////////////////////////////////
// 0x08: Instrument effect
if((channelInfo & patInsEff) != 0)
{
effect1 = file.ReadUint8();
effectParam1 = file.ReadUint8();
switch(effect1)
{
case 1: // Stop Sample
m->note = NOTE_NOTECUT;
effect1 = CMD_NONE;
break;
case 2: // Stop Sample Loop
m->note = NOTE_KEYOFF;
effect1 = CMD_NONE;
break;
case 3: // Instrument Volume Override (aka "Restart")
m->note = settings.channels[chn].lastNote;
settings.channels[chn].playDir = false;
effect1 = CMD_NONE;
break;
case 4: // Sample Delay
effectParam1 = DMFdelay2MPT(effectParam1, settings.internalTicks);
if(effectParam1)
{
effect1 = CMD_S3MCMDEX;
effectParam1 = 0xD0 | (effectParam1);
} else
{
effect1 = CMD_NONE;
}
if(m->note == NOTE_NONE)
{
m->note = settings.channels[chn].lastNote;
settings.channels[chn].playDir = false;
}
break;
case 5: // Tremolo Retrig Sample (who invented those stupid effect names?)
effectParam1 = std::max(uint8(1), DMFdelay2MPT(effectParam1, settings.internalTicks));
effect1 = CMD_RETRIG;
settings.channels[chn].playDir = false;
break;
case 6: // Offset
case 7: // Offset + 64k
case 8: // Offset + 128k
case 9: // Offset + 192k
// Put high offset on previous row
if(row > 0 && effect1 != settings.channels[chn].highOffset)
{
if(sndFile.Patterns[pat].WriteEffect(EffectWriter(CMD_S3MCMDEX, (0xA0 | (effect1 - 6))).Row(row - 1).Channel(chn).RetryPreviousRow()))
{
settings.channels[chn].highOffset = effect1;
}
}
effect1 = CMD_OFFSET;
if(m->note == NOTE_NONE)
{
// Offset without note does also work in DMF.
m->note = settings.channels[chn].lastNote;
}
settings.channels[chn].playDir = false;
break;
case 10: // Invert Sample play direction ("Tekkno Invert")
effect1 = CMD_S3MCMDEX;
if(settings.channels[chn].playDir == false)
effectParam1 = 0x9F;
else
effectParam1 = 0x9E;
settings.channels[chn].playDir = !settings.channels[chn].playDir;
break;
default:
effect1 = CMD_NONE;
break;
}
}
////////////////////////////////////////////////////////////////
// 0x04: Note effect
if((channelInfo & patNoteEff) != 0)
{
effect2 = file.ReadUint8();
effectParam2 = file.ReadUint8();
switch(effect2)
{
case 1: // Note Finetune (1/16th of a semitone signed 8-bit value, not 1/128th as the interface claims)
{
const auto fine = std::div(static_cast<int8>(effectParam2) * 8, 128);
if(m->IsNote())
m->note = static_cast<ModCommand::NOTE>(Clamp(m->note + fine.quot, NOTE_MIN, NOTE_MAX));
effect2 = CMD_FINETUNE;
effectParam2 = static_cast<uint8>(fine.rem) ^ 0x80;
}
break;
case 2: // Note Delay (wtf is the difference to Sample Delay?)
effectParam2 = DMFdelay2MPT(effectParam2, settings.internalTicks);
if(effectParam2)
{
effect2 = CMD_S3MCMDEX;
effectParam2 = 0xD0 | (effectParam2);
} else
{
effect2 = CMD_NONE;
}
useMem2 = true;
break;
case 3: // Arpeggio
effect2 = CMD_ARPEGGIO;
useMem2 = true;
break;
case 4: // Portamento Up
case 5: // Portamento Down
effectParam2 = DMFporta2MPT(effectParam2, settings.internalTicks, true);
effect2 = (effect2 == 4) ? CMD_PORTAMENTOUP : CMD_PORTAMENTODOWN;
useMem2 = true;
break;
case 6: // Portamento to Note
if(m->note == NOTE_NONE)
{
m->note = settings.channels[chn].noteBuffer;
}
effectParam2 = DMFporta2MPT(effectParam2, settings.internalTicks, false);
effect2 = CMD_TONEPORTAMENTO;
useMem2 = true;
break;
case 7: // Scratch to Note (neat! but we don't have such an effect...)
m->note = static_cast<ModCommand::NOTE>(Clamp(effectParam2 + 25, NOTE_MIN, NOTE_MAX));
effect2 = CMD_TONEPORTAMENTO;
effectParam2 = 0xFF;
useMem2 = true;
break;
case 8: // Vibrato Sine
case 9: // Vibrato Triangle (ramp down should be close enough)
case 10: // Vibrato Square
// Put vibrato type on previous row
if(row > 0 && effect2 != settings.channels[chn].vibratoType)
{
if(sndFile.Patterns[pat].WriteEffect(EffectWriter(CMD_S3MCMDEX, (0x30 | (effect2 - 8))).Row(row - 1).Channel(chn).RetryPreviousRow()))
{
settings.channels[chn].vibratoType = effect2;
}
}
effect2 = CMD_VIBRATO;
effectParam2 = DMFvibrato2MPT(effectParam2, settings.internalTicks);
useMem2 = true;
break;
case 11: // Note Tremolo
effectParam2 = DMFtremor2MPT(effectParam2, settings.internalTicks);
effect2 = CMD_TREMOR;
useMem2 = true;
break;
case 12: // Note Cut
effectParam2 = DMFdelay2MPT(effectParam2, settings.internalTicks);
if(effectParam2)
{
effect2 = CMD_S3MCMDEX;
effectParam2 = 0xC0 | (effectParam2);
} else
{
effect2 = CMD_NONE;
m->note = NOTE_NOTECUT;
}
useMem2 = true;
break;
default:
effect2 = CMD_NONE;
break;
}
}
////////////////////////////////////////////////////////////////
// 0x02: Volume effect
if((channelInfo & patVolEff) != 0)
{
effect3 = file.ReadUint8();
effectParam3 = file.ReadUint8();
switch(effect3)
{
case 1: // Volume Slide Up
case 2: // Volume Slide Down
effectParam3 = DMFslide2MPT(effectParam3, settings.internalTicks, (effect3 == 1));
effect3 = CMD_VOLUMESLIDE;
useMem3 = true;
break;
case 3: // Volume Tremolo (actually this is Tremor)
effectParam3 = DMFtremor2MPT(effectParam3, settings.internalTicks);
effect3 = CMD_TREMOR;
useMem3 = true;
break;
case 4: // Tremolo Sine
case 5: // Tremolo Triangle (ramp down should be close enough)
case 6: // Tremolo Square
// Put tremolo type on previous row
if(row > 0 && effect3 != settings.channels[chn].tremoloType)
{
if(sndFile.Patterns[pat].WriteEffect(EffectWriter(CMD_S3MCMDEX, (0x40 | (effect3 - 4))).Row(row - 1).Channel(chn).RetryPreviousRow()))
{
settings.channels[chn].tremoloType = effect3;
}
}
effect3 = CMD_TREMOLO;
effectParam3 = DMFvibrato2MPT(effectParam3, settings.internalTicks);
useMem3 = true;
break;
case 7: // Set Balance
effect3 = CMD_PANNING8;
break;
case 8: // Slide Balance Left
case 9: // Slide Balance Right
effectParam3 = DMFslide2MPT(effectParam3, settings.internalTicks, (effect3 == 8));
effect3 = CMD_PANNINGSLIDE;
useMem3 = true;
break;
case 10: // Balance Vibrato Left/Right (always sine modulated)
effect3 = CMD_PANBRELLO;
effectParam3 = DMFvibrato2MPT(effectParam3, settings.internalTicks);
useMem3 = true;
break;
default:
effect3 = CMD_NONE;
break;
}
}
// Let's see if we can help the effect swapper by reducing some effect parameters to "continue" parameters.
if(useMem2)
ApplyEffectMemory(m, row, sndFile.GetNumChannels(), effect2, effectParam2);
if(useMem3)
ApplyEffectMemory(m, row, sndFile.GetNumChannels(), effect3, effectParam3);
// I guess this is close enough to "not retriggering the note"
if(slideNote && m->IsNote())
{
if(effect2 == CMD_NONE)
{
effect2 = CMD_TONEPORTAMENTO;
effectParam2 = 0xFF;
} else if(effect3 == CMD_NONE && effect2 != CMD_TONEPORTAMENTO) // Tone portamentos normally go in effect #2
{
effect3 = CMD_TONEPORTAMENTO;
effectParam3 = 0xFF;
}
}
// If one of the effects is unused, temporarily put volume commands in there
if(m->volcmd == VOLCMD_VOLUME)
{
if(effect2 == CMD_NONE)
{
effect2 = CMD_VOLUME;
effectParam2 = m->vol;
m->volcmd = VOLCMD_NONE;
} else if(effect3 == CMD_NONE)
{
effect3 = CMD_VOLUME;
effectParam3 = m->vol;
m->volcmd = VOLCMD_NONE;
}
}
ModCommand::TwoRegularCommandsToMPT(effect2, effectParam2, effect3, effectParam3);
if(m->volcmd == VOLCMD_NONE && effect2 != VOLCMD_NONE)
{
m->volcmd = effect2;
m->vol = effectParam2;
}
// Prefer instrument effects over any other effects
if(effect1 != CMD_NONE)
{
ModCommand::TwoRegularCommandsToMPT(effect3, effectParam3, effect1, effectParam1);
if(m->volcmd == VOLCMD_NONE && effect3 != VOLCMD_NONE)
{
m->volcmd = effect3;
m->vol = effectParam3;
}
m->command = effect1;
m->param = effectParam1;
} else if(effect3 != CMD_NONE)
{
m->command = effect3;
m->param = effectParam3;
}
} else
{
channelCounter[chn]--;
}
} // End for all channels
// Now we can try to write tempo information.
if(tempoChange)
{
tempoChange = false;
sndFile.Patterns[pat].WriteEffect(EffectWriter(CMD_TEMPO, static_cast<ModCommand::PARAM>(tempo)).Row(row).Channel(0).RetryNextRow());
sndFile.Patterns[pat].WriteEffect(EffectWriter(CMD_SPEED, static_cast<ModCommand::PARAM>(speed)).Row(row).RetryNextRow());
}
// Try to put delay effects somewhere as well
if(writeDelay & 0xF0)
{
sndFile.Patterns[pat].WriteEffect(EffectWriter(CMD_S3MCMDEX, 0xE0 | (writeDelay >> 4)).Row(row).AllowMultiple());
}
if(writeDelay & 0x0F)
{
const uint8 param = (writeDelay & 0x0F) * settings.internalTicks / 15;
sndFile.Patterns[pat].WriteEffect(EffectWriter(CMD_S3MCMDEX, 0x60u | Clamp(param, uint8(1), uint8(15))).Row(row).AllowMultiple());
}
writeDelay = 0;
} // End for all rows
return pat;
}
static bool ValidateHeader(const DMFFileHeader &fileHeader)
{
if(std::memcmp(fileHeader.signature, "DDMF", 4)
|| !fileHeader.version || fileHeader.version > 10)
{
return false;
}
return true;
}
CSoundFile::ProbeResult CSoundFile::ProbeFileHeaderDMF(MemoryFileReader file, const uint64 *pfilesize)
{
DMFFileHeader fileHeader;
if(!file.ReadStruct(fileHeader))
{
return ProbeWantMoreData;
}
if(!ValidateHeader(fileHeader))
{
return ProbeFailure;
}
MPT_UNREFERENCED_PARAMETER(pfilesize);
return ProbeSuccess;
}
bool CSoundFile::ReadDMF(FileReader &file, ModLoadingFlags loadFlags)
{
file.Rewind();
DMFFileHeader fileHeader;
if(!file.ReadStruct(fileHeader))
{
return false;
}
if(!ValidateHeader(fileHeader))
{
return false;
}
if(loadFlags == onlyVerifyHeader)
{
return true;
}
InitializeGlobals(MOD_TYPE_DMF);
m_modFormat.formatName = MPT_UFORMAT("X-Tracker v{}")(fileHeader.version);
m_modFormat.type = U_("dmf");
m_modFormat.charset = mpt::Charset::CP437;
m_songName = mpt::String::ReadBuf(mpt::String::spacePadded, fileHeader.songname);
m_songArtist = mpt::ToUnicode(mpt::Charset::CP437, mpt::String::ReadBuf(mpt::String::spacePadded, fileHeader.composer));
FileHistory mptHistory;
mptHistory.loadDate.tm_mday = Clamp(fileHeader.creationDay, uint8(1), uint8(31));
mptHistory.loadDate.tm_mon = Clamp(fileHeader.creationMonth, uint8(1), uint8(12)) - 1;
mptHistory.loadDate.tm_year = fileHeader.creationYear;
m_FileHistory.clear();
m_FileHistory.push_back(mptHistory);
// Go through all chunks now... cannot use our standard IFF chunk reader here because early X-Tracker versions write some malformed chunk headers... fun code ahead!
ChunkReader::ChunkList<DMFChunk> chunks;
while(file.CanRead(sizeof(DMFChunk)))
{
DMFChunk chunkHeader;
file.Read(chunkHeader);
uint32 chunkLength = chunkHeader.length, chunkSkip = 0;
// When loop start was added to version 3, the chunk size was not updated...
if(fileHeader.version == 3 && chunkHeader.GetID() == DMFChunk::idSEQU)
chunkSkip = 2;
// ...and when the loop end was added to version 4, it was also note updated! Luckily they fixed it in version 5.
else if(fileHeader.version == 4 && chunkHeader.GetID() == DMFChunk::idSEQU)
chunkSkip = 4;
// Earlier X-Tracker versions also write a garbage length for the SMPD chunk if samples are compressed.
// I don't know when exactly this stopped, but I have no version 5-7 files to check (and no X-Tracker version that writes those versions).
// Since this is practically always the last chunk in the file, the following code is safe for those versions, though.
else if(fileHeader.version < 8 && chunkHeader.GetID() == DMFChunk::idSMPD)
chunkLength = uint32_max;
chunks.chunks.push_back(ChunkReader::Item<DMFChunk>{chunkHeader, file.ReadChunk(chunkLength)});
file.Skip(chunkSkip);
}
FileReader chunk;
// Read order list
chunk = chunks.GetChunk(DMFChunk::idSEQU);
ORDERINDEX seqLoopStart = 0, seqLoopEnd = ORDERINDEX_MAX;
if(fileHeader.version >= 3)
seqLoopStart = chunk.ReadUint16LE();
if(fileHeader.version >= 4)
seqLoopEnd = chunk.ReadUint16LE();
// HIPOMATK.DMF has a loop end of 0, other v4 files have proper loop ends. Later X-Tracker versions import it as-is but it cannot be intentional.
// We just assume that this feature might have been buggy in early v4 versions and ignore the loop end in that case.
if(fileHeader.version == 4 && seqLoopEnd == 0)
seqLoopEnd = ORDERINDEX_MAX;
ReadOrderFromFile<uint16le>(Order(), chunk, chunk.BytesLeft() / 2);
LimitMax(seqLoopStart, Order().GetLastIndex());
LimitMax(seqLoopEnd, Order().GetLastIndex());
// Read patterns
chunk = chunks.GetChunk(DMFChunk::idPATT);
if(chunk.IsValid() && (loadFlags & loadPatternData))
{
DMFPatterns patHeader;
chunk.ReadStruct(patHeader);
m_nChannels = Clamp<uint8, uint8>(patHeader.numTracks, 1, 32) + 1; // + 1 for global track (used for tempo stuff)
// First, find out where all of our patterns are...
std::vector<FileReader> patternChunks(patHeader.numPatterns);
for(auto &patternChunk : patternChunks)
{
const uint8 headerSize = fileHeader.version < 3 ? 9 : 8;
chunk.Skip(headerSize - sizeof(uint32le));
const uint32 patLength = chunk.ReadUint32LE();
chunk.SkipBack(headerSize);
patternChunk = chunk.ReadChunk(headerSize + patLength);
}
// Now go through the order list and load them.
DMFPatternSettings settings(GetNumChannels());
Patterns.ResizeArray(Order().GetLength());
for(PATTERNINDEX &pat : Order())
{
// Create one pattern for each order item, as the same pattern can be played with different settings
if(pat < patternChunks.size())
{
pat = ConvertDMFPattern(patternChunks[pat], fileHeader.version, settings, *this);
}
}
// Write loop end if necessary
if(Order().IsValidPat(seqLoopEnd) && (seqLoopStart > 0 || seqLoopEnd < Order().GetLastIndex()))
{
PATTERNINDEX pat = Order()[seqLoopEnd];
Patterns[pat].WriteEffect(EffectWriter(CMD_POSITIONJUMP, static_cast<ModCommand::PARAM>(seqLoopStart)).Row(Patterns[pat].GetNumRows() - 1).RetryPreviousRow());
}
}
// Read song message
chunk = chunks.GetChunk(DMFChunk::idCMSG);
if(chunk.IsValid())
{
// The song message seems to start at a 1 byte offset.
// The skipped byte seems to always be 0.
// This also matches how XT 1.03 itself displays the song message.
chunk.Skip(1);
m_songMessage.ReadFixedLineLength(chunk, chunk.BytesLeft(), 40, 0);
}
// Read sample headers + data
FileReader sampleDataChunk = chunks.GetChunk(DMFChunk::idSMPD);
chunk = chunks.GetChunk(DMFChunk::idSMPI);
m_nSamples = chunk.ReadUint8();
for(SAMPLEINDEX smp = 1; smp <= GetNumSamples(); smp++)
{
const uint8 nameLength = (fileHeader.version < 2) ? 30 : chunk.ReadUint8();
chunk.ReadString<mpt::String::spacePadded>(m_szNames[smp], nameLength);
DMFSampleHeader sampleHeader;
ModSample &sample = Samples[smp];
chunk.ReadStruct(sampleHeader);
sampleHeader.ConvertToMPT(sample);
// Read library name in version 8 files
if(fileHeader.version >= 8)
chunk.ReadString<mpt::String::spacePadded>(sample.filename, 8);
// Filler + CRC
chunk.Skip(fileHeader.version > 1 ? 6 : 2);
// Now read the sample data from the data chunk
FileReader sampleData = sampleDataChunk.ReadChunk(sampleDataChunk.ReadUint32LE());
if(sampleData.IsValid() && (loadFlags & loadSampleData))
{
SampleIO(
sample.uFlags[CHN_16BIT] ? SampleIO::_16bit : SampleIO::_8bit,
SampleIO::mono,
SampleIO::littleEndian,
(sampleHeader.flags & DMFSampleHeader::smpCompMask) == DMFSampleHeader::smpComp1 ? SampleIO::DMF : SampleIO::signedPCM)
.ReadSample(sample, sampleData);
}
}
InitializeChannels();
m_SongFlags = SONG_LINEARSLIDES | SONG_ITCOMPATGXX; // this will be converted to IT format by MPT. SONG_ITOLDEFFECTS is not set because of tremor and vibrato.
m_nDefaultSpeed = 6;
m_nDefaultTempo.Set(120);
m_nDefaultGlobalVolume = 256;
m_nSamplePreAmp = m_nVSTiVolume = 48;
m_playBehaviour.set(kApplyOffsetWithoutNote);
return true;
}
///////////////////////////////////////////////////////////////////////
// DMF Compression
struct DMFHNode
{
int16 left, right;
uint8 value;
};
struct DMFHTree
{
BitReader file;
int lastnode = 0, nodecount = 0;
DMFHNode nodes[256]{};
DMFHTree(FileReader &file)
: file(file)
{
}
//
// tree: [8-bit value][12-bit index][12-bit index] = 32-bit
//
void DMFNewNode()
{
int actnode = nodecount;
if(actnode > 255) return;
nodes[actnode].value = static_cast<uint8>(file.ReadBits(7));
bool isLeft = file.ReadBits(1) != 0;
bool isRight = file.ReadBits(1) != 0;
actnode = lastnode;
if(actnode > 255) return;
nodecount++;
lastnode = nodecount;
if(isLeft)
{
nodes[actnode].left = (int16)lastnode;
DMFNewNode();
} else
{
nodes[actnode].left = -1;
}
lastnode = nodecount;
if(isRight)
{
nodes[actnode].right = (int16)lastnode;
DMFNewNode();
} else
{
nodes[actnode].right = -1;
}
}
};
uintptr_t DMFUnpack(FileReader &file, uint8 *psample, uint32 maxlen)
{
DMFHTree tree(file);
uint8 value = 0, delta = 0;
try
{
tree.DMFNewNode();
if(tree.nodes[0].left < 0 || tree.nodes[0].right < 0)
return tree.file.GetPosition();
for(uint32 i = 0; i < maxlen; i++)
{
int actnode = 0;
bool sign = tree.file.ReadBits(1) != 0;
do
{
if(tree.file.ReadBits(1))
actnode = tree.nodes[actnode].right;
else
actnode = tree.nodes[actnode].left;
if(actnode > 255) break;
delta = tree.nodes[actnode].value;
} while((tree.nodes[actnode].left >= 0) && (tree.nodes[actnode].right >= 0));
if(sign) delta ^= 0xFF;
value += delta;
psample[i] = value;
}
} catch(const BitReader::eof &)
{
//AddToLog(LogWarning, "Truncated DMF sample block");
}
return tree.file.GetPosition();
}
OPENMPT_NAMESPACE_END
Reference in a new issue View git blame Copy permalink