random-mirrors
/
winamp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/soundlib/Load_s3m.cpp

1091 lines
36 KiB
C++
Raw Permalink Normal View History

Initial community commit
2024-09-24 13:54:57 +01:00
/*
* Load_s3m.cpp
* ------------
* Purpose: S3M (ScreamTracker 3) module loader / saver
* 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"
#include "S3MTools.h"
#include "ITTools.h"
#ifndef MODPLUG_NO_FILESAVE
#include "mpt/io/base.hpp"
#include "mpt/io/io.hpp"
#include "mpt/io/io_stdstream.hpp"
#include "../common/mptFileIO.h"
#ifdef MODPLUG_TRACKER
#include "../mptrack/TrackerSettings.h"
#endif // MODPLUG_TRACKER
#endif // MODPLUG_NO_FILESAVE
#include "../common/version.h"
OPENMPT_NAMESPACE_BEGIN
void CSoundFile::S3MConvert(ModCommand &m, bool fromIT)
{
switch(m.command | 0x40)
{
case '@': m.command = (m.param ? CMD_DUMMY : CMD_NONE); break;
case 'A': m.command = CMD_SPEED; break;
case 'B': m.command = CMD_POSITIONJUMP; break;
case 'C': m.command = CMD_PATTERNBREAK; if (!fromIT) m.param = (m.param >> 4) * 10 + (m.param & 0x0F); break;
case 'D': m.command = CMD_VOLUMESLIDE; break;
case 'E': m.command = CMD_PORTAMENTODOWN; break;
case 'F': m.command = CMD_PORTAMENTOUP; break;
case 'G': m.command = CMD_TONEPORTAMENTO; break;
case 'H': m.command = CMD_VIBRATO; break;
case 'I': m.command = CMD_TREMOR; break;
case 'J': m.command = CMD_ARPEGGIO; break;
case 'K': m.command = CMD_VIBRATOVOL; break;
case 'L': m.command = CMD_TONEPORTAVOL; break;
case 'M': m.command = CMD_CHANNELVOLUME; break;
case 'N': m.command = CMD_CHANNELVOLSLIDE; break;
case 'O': m.command = CMD_OFFSET; break;
case 'P': m.command = CMD_PANNINGSLIDE; break;
case 'Q': m.command = CMD_RETRIG; break;
case 'R': m.command = CMD_TREMOLO; break;
case 'S': m.command = CMD_S3MCMDEX; break;
case 'T': m.command = CMD_TEMPO; break;
case 'U': m.command = CMD_FINEVIBRATO; break;
case 'V': m.command = CMD_GLOBALVOLUME; break;
case 'W': m.command = CMD_GLOBALVOLSLIDE; break;
case 'X': m.command = CMD_PANNING8; break;
case 'Y': m.command = CMD_PANBRELLO; break;
case 'Z': m.command = CMD_MIDI; break;
case '\\': m.command = fromIT ? CMD_SMOOTHMIDI : CMD_MIDI; break;
// Chars under 0x40 don't save properly, so the following commands don't map to their pattern editor representations
case ']': m.command = fromIT ? CMD_DELAYCUT : CMD_NONE; break;
case '[': m.command = fromIT ? CMD_XPARAM : CMD_NONE; break;
case '^': m.command = fromIT ? CMD_FINETUNE : CMD_NONE; break;
case '_': m.command = fromIT ? CMD_FINETUNE_SMOOTH : CMD_NONE; break;
// BeRoTracker extensions
case '1' + 0x41: m.command = fromIT ? CMD_KEYOFF : CMD_NONE; break;
case '2' + 0x41: m.command = fromIT ? CMD_SETENVPOSITION : CMD_NONE; break;
default: m.command = CMD_NONE;
}
}
#ifndef MODPLUG_NO_FILESAVE
void CSoundFile::S3MSaveConvert(uint8 &command, uint8 &param, bool toIT, bool compatibilityExport) const
{
const bool extendedIT = !compatibilityExport && toIT;
switch(command)
{
case CMD_DUMMY: command = (param ? '@' : 0); break;
case CMD_SPEED: command = 'A'; break;
case CMD_POSITIONJUMP: command = 'B'; break;
case CMD_PATTERNBREAK: command = 'C'; if(!toIT) param = ((param / 10) << 4) + (param % 10); break;
case CMD_VOLUMESLIDE: command = 'D'; break;
case CMD_PORTAMENTODOWN: command = 'E'; if (param >= 0xE0 && (GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM))) param = 0xDF; break;
case CMD_PORTAMENTOUP: command = 'F'; if (param >= 0xE0 && (GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM))) param = 0xDF; break;
case CMD_TONEPORTAMENTO: command = 'G'; break;
case CMD_VIBRATO: command = 'H'; break;
case CMD_TREMOR: command = 'I'; break;
case CMD_ARPEGGIO: command = 'J'; break;
case CMD_VIBRATOVOL: command = 'K'; break;
case CMD_TONEPORTAVOL: command = 'L'; break;
case CMD_CHANNELVOLUME: command = 'M'; break;
case CMD_CHANNELVOLSLIDE: command = 'N'; break;
case CMD_OFFSETPERCENTAGE:
case CMD_OFFSET: command = 'O'; break;
case CMD_PANNINGSLIDE: command = 'P'; break;
case CMD_RETRIG: command = 'Q'; break;
case CMD_TREMOLO: command = 'R'; break;
case CMD_S3MCMDEX: command = 'S'; break;
case CMD_TEMPO: command = 'T'; break;
case CMD_FINEVIBRATO: command = 'U'; break;
case CMD_GLOBALVOLUME: command = 'V'; break;
case CMD_GLOBALVOLSLIDE: command = 'W'; break;
case CMD_PANNING8:
command = 'X';
if(toIT && !(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_XM | MOD_TYPE_MOD)))
{
if (param == 0xA4) { command = 'S'; param = 0x91; }
else if (param == 0x80) { param = 0xFF; }
else if (param < 0x80) { param <<= 1; }
else command = 0;
} else if (!toIT && (GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_XM | MOD_TYPE_MOD)))
{
param >>= 1;
}
break;
case CMD_PANBRELLO: command = 'Y'; break;
case CMD_MIDI: command = 'Z'; break;
case CMD_SMOOTHMIDI:
if(extendedIT)
command = '\\';
else
command = 'Z';
break;
case CMD_XFINEPORTAUPDOWN:
switch(param & 0xF0)
{
case 0x10: command = 'F'; param = (param & 0x0F) | 0xE0; break;
case 0x20: command = 'E'; param = (param & 0x0F) | 0xE0; break;
case 0x90: command = 'S'; break;
default: command = 0;
}
break;
case CMD_MODCMDEX:
{
ModCommand m;
m.command = CMD_MODCMDEX;
m.param = param;
m.ExtendedMODtoS3MEffect();
command = m.command;
param = m.param;
S3MSaveConvert(command, param, toIT, compatibilityExport);
}
return;
// Chars under 0x40 don't save properly, so map : to ] and # to [.
case CMD_DELAYCUT:
command = extendedIT ? ']' : 0;
break;
case CMD_XPARAM:
command = extendedIT ? '[' : 0;
break;
case CMD_FINETUNE:
command = extendedIT ? '^' : 0;
break;
case CMD_FINETUNE_SMOOTH:
command = extendedIT ? '_' : 0;
break;
default:
command = 0;
}
if(command == 0)
{
param = 0;
}
command &= ~0x40;
}
#endif // MODPLUG_NO_FILESAVE
static bool ValidateHeader(const S3MFileHeader &fileHeader)
{
if(std::memcmp(fileHeader.magic, "SCRM", 4)
|| fileHeader.fileType != S3MFileHeader::idS3MType
|| (fileHeader.formatVersion != S3MFileHeader::oldVersion && fileHeader.formatVersion != S3MFileHeader::newVersion)
)
{
return false;
}
return true;
}
static uint64 GetHeaderMinimumAdditionalSize(const S3MFileHeader &fileHeader)
{
return fileHeader.ordNum + (fileHeader.smpNum + fileHeader.patNum) * 2;
}
CSoundFile::ProbeResult CSoundFile::ProbeFileHeaderS3M(MemoryFileReader file, const uint64 *pfilesize)
{
S3MFileHeader fileHeader;
if(!file.ReadStruct(fileHeader))
{
return ProbeWantMoreData;
}
if(!ValidateHeader(fileHeader))
{
return ProbeFailure;
}
return ProbeAdditionalSize(file, pfilesize, GetHeaderMinimumAdditionalSize(fileHeader));
}
bool CSoundFile::ReadS3M(FileReader &file, ModLoadingFlags loadFlags)
{
file.Rewind();
// Is it a valid S3M file?
S3MFileHeader 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_S3M);
m_nMinPeriod = 64;
m_nMaxPeriod = 32767;
// ST3 ignored Zxx commands, so if we find that a file was made with ST3, we should erase all MIDI macros.
bool keepMidiMacros = false;
mpt::ustring madeWithTracker;
bool formatTrackerStr = false;
bool nonCompatTracker = false;
bool isST3 = false;
bool isSchism = false;
const int32 schismDateVersion = SchismTrackerEpoch + ((fileHeader.cwtv == 0x4FFF) ? fileHeader.reserved2 : (fileHeader.cwtv - 0x4050));
switch(fileHeader.cwtv & S3MFileHeader::trackerMask)
{
case S3MFileHeader::trkAkord & S3MFileHeader::trackerMask:
if(fileHeader.cwtv == S3MFileHeader::trkAkord)
madeWithTracker = U_("Akord");
break;
case S3MFileHeader::trkScreamTracker:
if(fileHeader.cwtv == S3MFileHeader::trkST3_20 && fileHeader.special == 0 && (fileHeader.ordNum & 0x0F) == 0 && fileHeader.ultraClicks == 0 && (fileHeader.flags & ~0x50) == 0)
{
// MPT and OpenMPT before 1.17.03.02 - Simply keep default (filter) MIDI macros
if((fileHeader.masterVolume & 0x80) != 0)
{
m_dwLastSavedWithVersion = MPT_V("1.16.00.00");
madeWithTracker = U_("ModPlug Tracker / OpenMPT 1.17");
} else
{
// MPT 1.0 alpha5 doesn't set the stereo flag, but MPT 1.0 beta1 does.
m_dwLastSavedWithVersion = MPT_V("1.00.00.00");
madeWithTracker = U_("ModPlug Tracker 1.0 alpha");
}
keepMidiMacros = true;
nonCompatTracker = true;
m_playBehaviour.set(kST3LimitPeriod);
} else if(fileHeader.cwtv == S3MFileHeader::trkST3_20 && fileHeader.special == 0 && fileHeader.ultraClicks == 0 && fileHeader.flags == 0 && fileHeader.usePanningTable == 0)
{
madeWithTracker = U_("Velvet Studio");
} else
{
// ST3.20 should only ever write ultra-click values 16, 24 and 32 (corresponding to 8, 12 and 16 in the GUI), ST3.01/3.03 should only write 0,
// though several ST3.01/3.03 files with ultra-click values of 16 have been found as well.
// However, we won't fingerprint these values here as it's unlikely that there is any other tracker out there disguising as ST3 and using a strange ultra-click value.
// Also, re-saving a file with a strange ultra-click value in ST3 doesn't fix this value unless the user manually changes it, or if it's below 16.
madeWithTracker = U_("Scream Tracker");
formatTrackerStr = true;
isST3 = true;
}
break;
case S3MFileHeader::trkImagoOrpheus:
madeWithTracker = U_("Imago Orpheus");
formatTrackerStr = true;
nonCompatTracker = true;
break;
case S3MFileHeader::trkImpulseTracker:
if(fileHeader.cwtv <= S3MFileHeader::trkIT2_14)
{
madeWithTracker = U_("Impulse Tracker");
formatTrackerStr = true;
} else
{
madeWithTracker = MPT_UFORMAT("Impulse Tracker 2.14p{}")(fileHeader.cwtv - S3MFileHeader::trkIT2_14);
}
if(fileHeader.cwtv >= S3MFileHeader::trkIT2_07 && fileHeader.reserved3 != 0)
{
// Starting from version 2.07, IT stores the total edit time of a module in the "reserved" field
uint32 editTime = DecodeITEditTimer(fileHeader.cwtv, fileHeader.reserved3);
FileHistory hist;
hist.openTime = static_cast<uint32>(editTime * (HISTORY_TIMER_PRECISION / 18.2));
m_FileHistory.push_back(hist);
}
nonCompatTracker = true;
m_playBehaviour.set(kPeriodsAreHertz);
m_playBehaviour.set(kITRetrigger);
m_playBehaviour.set(kITShortSampleRetrig);
m_playBehaviour.set(kST3SampleSwap); // Not exactly like ST3, but close enough
m_nMinPeriod = 1;
break;
case S3MFileHeader::trkSchismTracker:
if(fileHeader.cwtv == S3MFileHeader::trkBeRoTrackerOld)
{
madeWithTracker = U_("BeRoTracker");
m_playBehaviour.set(kST3LimitPeriod);
} else
{
madeWithTracker = GetSchismTrackerVersion(fileHeader.cwtv, fileHeader.reserved2);
m_nMinPeriod = 1;
isSchism = true;
if(schismDateVersion >= SchismVersionFromDate<2021, 05, 02>::date)
m_playBehaviour.set(kPeriodsAreHertz);
if(schismDateVersion >= SchismVersionFromDate<2016, 05, 13>::date)
m_playBehaviour.set(kITShortSampleRetrig);
}
nonCompatTracker = true;
break;
case S3MFileHeader::trkOpenMPT:
{
uint32 mptVersion = (fileHeader.cwtv & S3MFileHeader::versionMask) << 16;
if(mptVersion >= 0x01'29'00'00)
mptVersion |= fileHeader.reserved2;
m_dwLastSavedWithVersion = Version(mptVersion);
madeWithTracker = U_("OpenMPT ") + mpt::ufmt::val(m_dwLastSavedWithVersion);
}
break;
case S3MFileHeader::trkBeRoTracker:
madeWithTracker = U_("BeRoTracker");
m_playBehaviour.set(kST3LimitPeriod);
break;
case S3MFileHeader::trkCreamTracker:
madeWithTracker = U_("CreamTracker");
break;
default:
if(fileHeader.cwtv == S3MFileHeader::trkCamoto)
madeWithTracker = U_("Camoto");
break;
}
if(formatTrackerStr)
{
madeWithTracker = MPT_UFORMAT("{} {}.{}")(madeWithTracker, (fileHeader.cwtv & 0xF00) >> 8, mpt::ufmt::hex0<2>(fileHeader.cwtv & 0xFF));
}
m_modFormat.formatName = U_("Scream Tracker 3");
m_modFormat.type = U_("s3m");
m_modFormat.madeWithTracker = std::move(madeWithTracker);
m_modFormat.charset = m_dwLastSavedWithVersion ? mpt::Charset::Windows1252 : mpt::Charset::CP437;
if(nonCompatTracker)
{
m_playBehaviour.reset(kST3NoMutedChannels);
m_playBehaviour.reset(kST3EffectMemory);
m_playBehaviour.reset(kST3PortaSampleChange);
m_playBehaviour.reset(kST3VibratoMemory);
m_playBehaviour.reset(KST3PortaAfterArpeggio);
m_playBehaviour.reset(kST3OffsetWithoutInstrument);
m_playBehaviour.reset(kApplyUpperPeriodLimit);
}
if((fileHeader.cwtv & S3MFileHeader::trackerMask) > S3MFileHeader::trkScreamTracker)
{
if((fileHeader.cwtv & S3MFileHeader::trackerMask) != S3MFileHeader::trkImpulseTracker || fileHeader.cwtv >= S3MFileHeader::trkIT2_14)
{
// Keep MIDI macros if this is not an old IT version (BABYLON.S3M by Necros has Zxx commands and was saved with IT 2.05)
keepMidiMacros = true;
}
}
m_MidiCfg.Reset();
if(!keepMidiMacros)
{
// Remove macros so they don't interfere with tunes made in trackers that don't support Zxx
m_MidiCfg.ClearZxxMacros();
}
m_songName = mpt::String::ReadBuf(mpt::String::nullTerminated, fileHeader.name);
if(fileHeader.flags & S3MFileHeader::amigaLimits) m_SongFlags.set(SONG_AMIGALIMITS);
if(fileHeader.flags & S3MFileHeader::st2Vibrato) m_SongFlags.set(SONG_S3MOLDVIBRATO);
if(fileHeader.cwtv == S3MFileHeader::trkST3_00 || (fileHeader.flags & S3MFileHeader::fastVolumeSlides) != 0)
{
m_SongFlags.set(SONG_FASTVOLSLIDES);
}
// Speed
m_nDefaultSpeed = fileHeader.speed;
if(m_nDefaultSpeed == 0 || (m_nDefaultSpeed == 255 && isST3))
{
// Even though ST3 accepts the command AFF as expected, it mysteriously fails to load a default speed of 255...
m_nDefaultSpeed = 6;
}
// Tempo
m_nDefaultTempo.Set(fileHeader.tempo);
if(fileHeader.tempo < 33)
{
// ST3 also fails to load an otherwise valid default tempo of 32...
m_nDefaultTempo.Set(isST3 ? 125 : 32);
}
// Global Volume
m_nDefaultGlobalVolume = std::min(fileHeader.globalVol.get(), uint8(64)) * 4u;
// The following check is probably not very reliable, but it fixes a few tunes, e.g.
// DARKNESS.S3M by Purple Motion (ST 3.00) and "Image of Variance" by C.C.Catch (ST 3.01):
if(m_nDefaultGlobalVolume == 0 && fileHeader.cwtv < S3MFileHeader::trkST3_20)
{
m_nDefaultGlobalVolume = MAX_GLOBAL_VOLUME;
}
if(fileHeader.formatVersion == S3MFileHeader::oldVersion && fileHeader.masterVolume < 8)
m_nSamplePreAmp = std::min((fileHeader.masterVolume + 1) * 0x10, 0x7F);
// These changes were probably only supposed to be done for older format revisions, where supposedly 0x10 was the stereo flag.
// However, this version check is missing in ST3, so any mono file with a master volume of 18 will be converted to a stereo file with master volume 32.
else if(fileHeader.masterVolume == 2 || fileHeader.masterVolume == (2 | 0x10))
m_nSamplePreAmp = 0x20;
else if(!(fileHeader.masterVolume & 0x7F))
m_nSamplePreAmp = 48;
else
m_nSamplePreAmp = std::max(fileHeader.masterVolume & 0x7F, 0x10); // Bit 7 = Stereo (we always use stereo)
const bool isStereo = (fileHeader.masterVolume & 0x80) != 0 || m_dwLastSavedWithVersion;
if(!isStereo)
m_nSamplePreAmp = Util::muldivr_unsigned(m_nSamplePreAmp, 8, 11);
// Approximately as loud as in DOSBox and a real SoundBlaster 16
m_nVSTiVolume = 36;
if(isSchism && schismDateVersion < SchismVersionFromDate<2018, 11, 12>::date)
m_nVSTiVolume = 64;
// Channel setup
m_nChannels = 4;
std::bitset<32> isAdlibChannel;
for(CHANNELINDEX i = 0; i < 32; i++)
{
ChnSettings[i].Reset();
uint8 ctype = fileHeader.channels[i] & ~0x80;
if(fileHeader.channels[i] != 0xFF)
{
m_nChannels = i + 1;
if(isStereo)
ChnSettings[i].nPan = (ctype & 8) ? 0xCC : 0x33; // 200 : 56
}
if(fileHeader.channels[i] & 0x80)
{
ChnSettings[i].dwFlags = CHN_MUTE;
}
if(ctype >= 16 && ctype <= 29)
{
// Adlib channel - except for OpenMPT 1.19 and older, which would write wrong channel types for PCM channels 16-32.
// However, MPT/OpenMPT always wrote the extra panning table, so there is no need to consider this here.
ChnSettings[i].nPan = 128;
isAdlibChannel[i] = true;
}
}
if(m_nChannels < 1)
{
m_nChannels = 1;
}
ReadOrderFromFile<uint8>(Order(), file, fileHeader.ordNum, 0xFF, 0xFE);
// Read sample header offsets
std::vector<uint16le> sampleOffsets;
file.ReadVector(sampleOffsets, fileHeader.smpNum);
// Read pattern offsets
std::vector<uint16le> patternOffsets;
file.ReadVector(patternOffsets, fileHeader.patNum);
// Read extended channel panning
if(fileHeader.usePanningTable == S3MFileHeader::idPanning)
{
uint8 pan[32];
file.ReadArray(pan);
for(CHANNELINDEX i = 0; i < 32; i++)
{
if((pan[i] & 0x20) != 0 && (!isST3 || !isAdlibChannel[i]))
{
ChnSettings[i].nPan = (static_cast<uint16>(pan[i] & 0x0F) * 256 + 8) / 15;
}
}
}
// Reading sample headers
m_nSamples = std::min(static_cast<SAMPLEINDEX>(fileHeader.smpNum), static_cast<SAMPLEINDEX>(MAX_SAMPLES - 1));
bool anySamples = false;
uint16 gusAddresses = 0;
for(SAMPLEINDEX smp = 0; smp < m_nSamples; smp++)
{
S3MSampleHeader sampleHeader;
if(!file.Seek(sampleOffsets[smp] * 16) || !file.ReadStruct(sampleHeader))
{
continue;
}
sampleHeader.ConvertToMPT(Samples[smp + 1], isST3);
m_szNames[smp + 1] = mpt::String::ReadBuf(mpt::String::nullTerminated, sampleHeader.name);
if(sampleHeader.sampleType < S3MSampleHeader::typeAdMel)
{
const uint32 sampleOffset = sampleHeader.GetSampleOffset();
if((loadFlags & loadSampleData) && sampleHeader.length != 0 && file.Seek(sampleOffset))
{
sampleHeader.GetSampleFormat((fileHeader.formatVersion == S3MFileHeader::oldVersion)).ReadSample(Samples[smp + 1], file);
anySamples = true;
}
gusAddresses |= sampleHeader.gusAddress;
}
}
if(isST3 && anySamples && !gusAddresses && fileHeader.cwtv != S3MFileHeader::trkST3_00)
{
// All Scream Tracker versions except for some probably early revisions of Scream Tracker 3.00 write GUS addresses. GUS support might not have existed at that point (1992).
// Hence if a file claims to be written with ST3 (but not ST3.00), but has no GUS addresses, we deduce that it must be written by some other software (e.g. some PSM -> S3M conversions)
isST3 = false;
MPT_UNUSED(isST3);
m_modFormat.madeWithTracker = U_("Unknown");
} else if(isST3)
{
// Saving an S3M file in ST3 with the Gravis Ultrasound driver loaded will write a unique GUS memory address for each non-empty sample slot (and 0 for unused slots).
// Re-saving that file in ST3 with the SoundBlaster driver loaded will reset the GUS address for all samples to 0 (unused) or 1 (used).
// The first used sample will also have an address of 1 with the GUS driver.
// So this is a safe way of telling if the file was last saved with the GUS driver loaded or not if there's more than one sample.
const bool useGUS = gusAddresses > 1;
m_playBehaviour.set(kST3PortaSampleChange, useGUS);
m_playBehaviour.set(kST3SampleSwap, !useGUS);
m_playBehaviour.set(kITShortSampleRetrig, !useGUS); // Only half the truth but close enough for now
m_modFormat.madeWithTracker += useGUS ? UL_(" (GUS)") : UL_(" (SB)");
// ST3's GUS driver doesn't use this value. Ignoring it fixes the balance between FM and PCM samples (e.g. in Rotagilla by Manwe)
if(useGUS)
m_nSamplePreAmp = 48;
}
// Try to find out if Zxx commands are supposed to be panning commands (PixPlay).
// Actually I am only aware of one module that uses this panning style, namely "Crawling Despair" by $volkraq
// and I have no idea what PixPlay is, so this code is solely based on the sample text of that module.
// We won't convert if there are not enough Zxx commands, too "high" Zxx commands
// or there are only "left" or "right" pannings (we assume that stereo should be somewhat balanced),
// and modules not made with an old version of ST3 were probably made in a tracker that supports panning anyway.
bool pixPlayPanning = (fileHeader.cwtv < S3MFileHeader::trkST3_20);
int zxxCountRight = 0, zxxCountLeft = 0;
// Reading patterns
if(!(loadFlags & loadPatternData))
{
return true;
}
// Order list cannot contain pattern indices > 255, so do not even try to load higher patterns
const PATTERNINDEX readPatterns = std::min(static_cast<PATTERNINDEX>(fileHeader.patNum), static_cast<PATTERNINDEX>(uint8_max));
Patterns.ResizeArray(readPatterns);
for(PATTERNINDEX pat = 0; pat < readPatterns; pat++)
{
// A zero parapointer indicates an empty pattern.
if(!Patterns.Insert(pat, 64) || patternOffsets[pat] == 0 || !file.Seek(patternOffsets[pat] * 16))
{
continue;
}
// Skip pattern length indication.
// Some modules, for example http://aminet.net/mods/8voic/s3m_hunt.lha seem to have a wrong pattern length -
// If you strictly adhere the pattern length, you won't read some patterns (e.g. 17) correctly in that module.
// It's most likely a broken copy because there are other versions of the track which don't have this issue.
// Still, we don't really need this information, so we just ignore it.
file.Skip(2);
// Read pattern data
ROWINDEX row = 0;
PatternRow rowBase = Patterns[pat].GetRow(0);
while(row < 64)
{
uint8 info = file.ReadUint8();
if(info == s3mEndOfRow)
{
// End of row
if(++row < 64)
{
rowBase = Patterns[pat].GetRow(row);
}
continue;
}
CHANNELINDEX channel = (info & s3mChannelMask);
ModCommand dummy;
ModCommand &m = (channel < GetNumChannels()) ? rowBase[channel] : dummy;
if(info & s3mNotePresent)
{
const auto [note, instr] = file.ReadArray<uint8, 2>();
if(note < 0xF0)
m.note = static_cast<ModCommand::NOTE>(Clamp((note & 0x0F) + 12 * (note >> 4) + 12 + NOTE_MIN, NOTE_MIN, NOTE_MAX));
else if(note == s3mNoteOff)
m.note = NOTE_NOTECUT;
else if(note == s3mNoteNone)
m.note = NOTE_NONE;
m.instr = instr;
}
if(info & s3mVolumePresent)
{
uint8 volume = file.ReadUint8();
if(volume >= 128 && volume <= 192)
{
m.volcmd = VOLCMD_PANNING;
m.vol = volume - 128;
} else
{
m.volcmd = VOLCMD_VOLUME;
m.vol = std::min(volume, uint8(64));
}
}
if(info & s3mEffectPresent)
{
const auto [command, param] = file.ReadArray<uint8, 2>();
m.command = command;
m.param = param;
S3MConvert(m, false);
if(m.command == CMD_S3MCMDEX && (m.param & 0xF0) == 0xA0 && fileHeader.cwtv < S3MFileHeader::trkST3_20)
{
// Convert old SAx panning to S8x (should only be found in PANIC.S3M by Purple Motion)
m.param = 0x80 | ((m.param & 0x0F) ^ 8);
} else if(m.command == CMD_MIDI)
{
// PixPlay panning test
if(m.param > 0x0F)
{
// PixPlay has Z00 to Z0F panning, so we ignore this.
pixPlayPanning = false;
} else
{
if(m.param < 0x08)
zxxCountLeft++;
else if(m.param > 0x08)
zxxCountRight++;
}
} else if(m.command == CMD_OFFSET && m.param == 0 && fileHeader.cwtv <= S3MFileHeader::trkST3_01)
{
// Offset command didn't have effect memory in ST3.01; fixed in ST3.03
m.command = CMD_DUMMY;
}
}
}
}
if(pixPlayPanning && zxxCountLeft + zxxCountRight >= m_nChannels && (-zxxCountLeft + zxxCountRight) < static_cast<int>(m_nChannels))
{
// There are enough Zxx commands, so let's assume this was made to be played with PixPlay
Patterns.ForEachModCommand([](ModCommand &m)
{
if(m.command == CMD_MIDI)
{
m.command = CMD_S3MCMDEX;
m.param |= 0x80;
}
});
}
return true;
}
#ifndef MODPLUG_NO_FILESAVE
bool CSoundFile::SaveS3M(std::ostream &f) const
{
static constexpr uint8 filler[16] =
{
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};
if(m_nChannels == 0)
{
return false;
}
const bool saveMuteStatus =
#ifdef MODPLUG_TRACKER
TrackerSettings::Instance().MiscSaveChannelMuteStatus;
#else
true;
#endif
S3MFileHeader fileHeader;
MemsetZero(fileHeader);
mpt::String::WriteBuf(mpt::String::nullTerminated, fileHeader.name) = m_songName;
fileHeader.dosEof = S3MFileHeader::idEOF;
fileHeader.fileType = S3MFileHeader::idS3MType;
// Orders
ORDERINDEX writeOrders = Order().GetLengthTailTrimmed();
if(writeOrders < 2)
{
writeOrders = 2;
} else if((writeOrders % 2u) != 0)
{
// Number of orders should be even
writeOrders++;
}
LimitMax(writeOrders, static_cast<ORDERINDEX>(256));
fileHeader.ordNum = static_cast<uint16>(writeOrders);
// Samples
SAMPLEINDEX writeSamples = static_cast<SAMPLEINDEX>(GetNumInstruments());
if(writeSamples == 0)
{
writeSamples = GetNumSamples();
}
writeSamples = Clamp(writeSamples, static_cast<SAMPLEINDEX>(1), static_cast<SAMPLEINDEX>(99));
fileHeader.smpNum = static_cast<uint16>(writeSamples);
// Patterns
PATTERNINDEX writePatterns = std::min(Patterns.GetNumPatterns(), PATTERNINDEX(100));
fileHeader.patNum = static_cast<uint16>(writePatterns);
// Flags
if(m_SongFlags[SONG_FASTVOLSLIDES])
{
fileHeader.flags |= S3MFileHeader::fastVolumeSlides;
}
if(m_nMaxPeriod < 20000 || m_SongFlags[SONG_AMIGALIMITS])
{
fileHeader.flags |= S3MFileHeader::amigaLimits;
}
if(m_SongFlags[SONG_S3MOLDVIBRATO])
{
fileHeader.flags |= S3MFileHeader::st2Vibrato;
}
// Version info following: ST3.20 = 0x1320
// Most significant nibble = Tracker ID, see S3MFileHeader::S3MTrackerVersions
// Following: One nibble = Major version, one byte = Minor version (hex)
const uint32 mptVersion = Version::Current().GetRawVersion();
fileHeader.cwtv = S3MFileHeader::trkOpenMPT | static_cast<uint16>((mptVersion >> 16) & S3MFileHeader::versionMask);
fileHeader.reserved2 = static_cast<uint16>(mptVersion);
fileHeader.formatVersion = S3MFileHeader::newVersion;
memcpy(fileHeader.magic, "SCRM", 4);
// Song Variables
fileHeader.globalVol = static_cast<uint8>(std::min(m_nDefaultGlobalVolume / 4u, uint32(64)));
fileHeader.speed = static_cast<uint8>(Clamp(m_nDefaultSpeed, 1u, 254u));
fileHeader.tempo = static_cast<uint8>(Clamp(m_nDefaultTempo.GetInt(), 33u, 255u));
fileHeader.masterVolume = static_cast<uint8>(Clamp(m_nSamplePreAmp, 16u, 127u) | 0x80);
fileHeader.ultraClicks = 16;
fileHeader.usePanningTable = S3MFileHeader::idPanning;
mpt::IO::Write(f, fileHeader);
Order().WriteAsByte(f, writeOrders);
// Comment about parapointers stolen from Schism Tracker:
// The sample data parapointers are 24+4 bits, whereas pattern data and sample headers are only 16+4
// bits -- so while the sample data can be written up to 268 MB within the file (starting at 0xffffff0),
// the pattern data and sample headers are restricted to the first 1 MB (starting at 0xffff0). In effect,
// this practically requires the sample data to be written last in the file, as it is entirely possible
// (and quite easy, even) to write more than 1 MB of sample data in a file.
// The "practical standard order" listed in TECH.DOC is sample headers, patterns, then sample data.
// Calculate offset of first sample header...
mpt::IO::Offset sampleHeaderOffset = mpt::IO::TellWrite(f) + (writeSamples + writePatterns) * 2 + 32;
// ...which must be a multiple of 16, because parapointers omit the lowest 4 bits.
sampleHeaderOffset = (sampleHeaderOffset + 15) & ~15;
std::vector<uint16le> sampleOffsets(writeSamples);
for(SAMPLEINDEX smp = 0; smp < writeSamples; smp++)
{
static_assert((sizeof(S3MSampleHeader) % 16) == 0);
sampleOffsets[smp] = static_cast<uint16>((sampleHeaderOffset + smp * sizeof(S3MSampleHeader)) / 16);
}
mpt::IO::Write(f, sampleOffsets);
mpt::IO::Offset patternPointerOffset = mpt::IO::TellWrite(f);
mpt::IO::Offset firstPatternOffset = sampleHeaderOffset + writeSamples * sizeof(S3MSampleHeader);
std::vector<uint16le> patternOffsets(writePatterns);
// Need to calculate the real offsets later.
mpt::IO::Write(f, patternOffsets);
// Write channel panning
uint8 chnPan[32];
for(CHANNELINDEX chn = 0; chn < 32; chn++)
{
if(chn < GetNumChannels())
chnPan[chn] = static_cast<uint8>(((ChnSettings[chn].nPan * 15 + 128) / 256) | 0x20);
else
chnPan[chn] = 0x08;
}
mpt::IO::Write(f, chnPan);
// Do we need to fill up the file with some padding bytes for 16-Byte alignment?
mpt::IO::Offset curPos = mpt::IO::TellWrite(f);
if(curPos < sampleHeaderOffset)
{
MPT_ASSERT(sampleHeaderOffset - curPos < 16);
mpt::IO::WriteRaw(f, filler, static_cast<std::size_t>(sampleHeaderOffset - curPos));
}
// Don't write sample headers for now, we are lacking the sample offset data.
mpt::IO::SeekAbsolute(f, firstPatternOffset);
// Write patterns
enum class S3MChannelType : uint8 { kUnused = 0, kPCM = 1, kAdlib = 2 };
FlagSet<S3MChannelType> channelType[32] = { S3MChannelType::kUnused };
bool globalCmdOnMutedChn = false;
for(PATTERNINDEX pat = 0; pat < writePatterns; pat++)
{
if(Patterns.IsPatternEmpty(pat))
{
patternOffsets[pat] = 0;
continue;
}
mpt::IO::Offset patOffset = mpt::IO::TellWrite(f);
if(patOffset > 0xFFFF0)
{
AddToLog(LogError, MPT_UFORMAT("Too much pattern data! Writing patterns failed starting from pattern {}.")(pat));
break;
}
MPT_ASSERT((patOffset % 16) == 0);
patternOffsets[pat] = static_cast<uint16>(patOffset / 16);
std::vector<uint8> buffer;
buffer.reserve(5 * 1024);
// Reserve space for length bytes
buffer.resize(2, 0);
if(Patterns.IsValidPat(pat))
{
for(ROWINDEX row = 0; row < 64; row++)
{
if(row >= Patterns[pat].GetNumRows())
{
// Invent empty row
buffer.push_back(s3mEndOfRow);
continue;
}
const PatternRow rowBase = Patterns[pat].GetRow(row);
CHANNELINDEX writeChannels = std::min(CHANNELINDEX(32), GetNumChannels());
for(CHANNELINDEX chn = 0; chn < writeChannels; chn++)
{
const ModCommand &m = rowBase[chn];
uint8 info = static_cast<uint8>(chn);
uint8 note = m.note;
ModCommand::VOLCMD volcmd = m.volcmd;
uint8 vol = m.vol;
uint8 command = m.command;
uint8 param = m.param;
if(note != NOTE_NONE || m.instr != 0)
{
info |= s3mNotePresent;
if(note == NOTE_NONE)
{
note = s3mNoteNone;
} else if(ModCommand::IsSpecialNote(note))
{
// Note Cut
note = s3mNoteOff;
} else if(note < 12 + NOTE_MIN)
{
// Too low
note = 0;
} else if(note <= NOTE_MAX)
{
note -= (12 + NOTE_MIN);
note = (note % 12) + ((note / 12) << 4);
}
if(m.instr > 0 && m.instr <= GetNumSamples())
{
const ModSample &smp = Samples[m.instr];
if(smp.uFlags[CHN_ADLIB])
channelType[chn].set(S3MChannelType::kAdlib);
else if(smp.HasSampleData())
channelType[chn].set(S3MChannelType::kPCM);
}
}
if(command == CMD_VOLUME)
{
command = CMD_NONE;
volcmd = VOLCMD_VOLUME;
vol = std::min(param, uint8(64));
}
if(volcmd == VOLCMD_VOLUME)
{
info |= s3mVolumePresent;
} else if(volcmd == VOLCMD_PANNING)
{
info |= s3mVolumePresent;
vol |= 0x80;
}
if(command != CMD_NONE)
{
S3MSaveConvert(command, param, false, true);
if(command || param)
{
info |= s3mEffectPresent;
if(saveMuteStatus && ChnSettings[chn].dwFlags[CHN_MUTE] && m.IsGlobalCommand())
{
globalCmdOnMutedChn = true;
}
}
}
if(info & s3mAnyPresent)
{
buffer.push_back(info);
if(info & s3mNotePresent)
{
buffer.push_back(note);
buffer.push_back(m.instr);
}
if(info & s3mVolumePresent)
{
buffer.push_back(vol);
}
if(info & s3mEffectPresent)
{
buffer.push_back(command);
buffer.push_back(param);
}
}
}
buffer.push_back(s3mEndOfRow);
}
} else
{
// Invent empty pattern
buffer.insert(buffer.end(), 64, s3mEndOfRow);
}
uint16 length = mpt::saturate_cast<uint16>(buffer.size());
buffer[0] = static_cast<uint8>(length & 0xFF);
buffer[1] = static_cast<uint8>((length >> 8) & 0xFF);
if((buffer.size() % 16u) != 0)
{
// Add padding bytes
buffer.insert(buffer.end(), 16 - (buffer.size() % 16u), 0);
}
mpt::IO::Write(f, buffer);
}
if(globalCmdOnMutedChn)
{
//AddToLog(LogWarning, U_("Global commands on muted channels are interpreted only by some S3M players."));
}
mpt::IO::Offset sampleDataOffset = mpt::IO::TellWrite(f);
// Write samples
std::vector<S3MSampleHeader> sampleHeader(writeSamples);
for(SAMPLEINDEX smp = 0; smp < writeSamples; smp++)
{
SAMPLEINDEX realSmp = smp + 1;
if(GetNumInstruments() != 0 && Instruments[smp] != nullptr)
{
// Find some valid sample associated with this instrument.
for(SAMPLEINDEX keySmp : Instruments[smp]->Keyboard)
{
if(keySmp > 0 && keySmp <= GetNumSamples())
{
realSmp = keySmp;
break;
}
}
}
if(realSmp > GetNumSamples())
{
continue;
}
const SmpLength smpLength = sampleHeader[smp].ConvertToS3M(Samples[realSmp]);
mpt::String::WriteBuf(mpt::String::nullTerminated, sampleHeader[smp].name) = m_szNames[realSmp];
if(smpLength != 0)
{
// Write sample data
if(sampleDataOffset > 0xFFFFFF0)
{
AddToLog(LogError, MPT_UFORMAT("Too much sample data! Writing samples failed starting from sample {}.")(realSmp));
break;
}
sampleHeader[smp].dataPointer[1] = static_cast<uint8>((sampleDataOffset >> 4) & 0xFF);
sampleHeader[smp].dataPointer[2] = static_cast<uint8>((sampleDataOffset >> 12) & 0xFF);
sampleHeader[smp].dataPointer[0] = static_cast<uint8>((sampleDataOffset >> 20) & 0xFF);
size_t writtenLength = sampleHeader[smp].GetSampleFormat(false).WriteSample(f, Samples[realSmp], smpLength);
sampleDataOffset += writtenLength;
if((writtenLength % 16u) != 0)
{
size_t fillSize = 16 - (writtenLength % 16u);
mpt::IO::WriteRaw(f, filler, fillSize);
sampleDataOffset += fillSize;
}
}
}
// Channel Table
uint8 sampleCh = 0, adlibCh = 0;
for(CHANNELINDEX chn = 0; chn < 32; chn++)
{
if(chn < GetNumChannels())
{
if(channelType[chn][S3MChannelType::kPCM] && channelType[chn][S3MChannelType::kAdlib])
{
AddToLog(LogWarning, MPT_UFORMAT("Pattern channel {} constains both samples and OPL instruments, which is not supported by Scream Tracker 3.")(chn + 1));
}
// ST3 only supports 16 PCM channels, so if channels 17-32 are used,
// they must be mapped to the same "internal channels" as channels 1-16.
// The channel indices determine in which order channels are evaluated in ST3.
// First, the "left" channels (0...7) are evaluated, then the "right" channels (8...15).
// Previously, an alternating LRLR scheme was written, which would lead to a different
// effect processing in ST3 than LLL...RRR, but since OpenMPT doesn't care about the
// channel order and always parses them left to right as they appear in the pattern,
// we should just write in the LLL...RRR manner.
uint8 ch = sampleCh % 16u; // If there are neither PCM nor AdLib instruments on this channel, just fall back a regular sample-based channel for maximum compatibility.
if(channelType[chn][S3MChannelType::kPCM])
ch = (sampleCh++) % 16u;
else if(channelType[chn][S3MChannelType::kAdlib])
ch = 16 + ((adlibCh++) % 9u);
if(saveMuteStatus && ChnSettings[chn].dwFlags[CHN_MUTE])
{
ch |= 0x80;
}
fileHeader.channels[chn] = ch;
} else
{
fileHeader.channels[chn] = 0xFF;
}
}
if(sampleCh > 16)
{
AddToLog(LogWarning, MPT_UFORMAT("This module has more than 16 ({}) sample channels, which is not supported by Scream Tracker 3.")(sampleCh));
}
if(adlibCh > 9)
{
AddToLog(LogWarning, MPT_UFORMAT("This module has more than 9 ({}) OPL channels, which is not supported by Scream Tracker 3.")(adlibCh));
}
mpt::IO::SeekAbsolute(f, 0);
mpt::IO::Write(f, fileHeader);
// Now we know where the patterns are.
if(writePatterns != 0)
{
mpt::IO::SeekAbsolute(f, patternPointerOffset);
mpt::IO::Write(f, patternOffsets);
}
// And we can finally write the sample headers.
if(writeSamples != 0)
{
mpt::IO::SeekAbsolute(f, sampleHeaderOffset);
mpt::IO::Write(f, sampleHeader);
}
return true;
}
#endif // MODPLUG_NO_FILESAVE
OPENMPT_NAMESPACE_END