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

6344 lines
201 KiB
C++
Raw Blame History

/*
* Snd_fx.cpp
* -----------
* Purpose: Processing of pattern commands, song length calculation...
* Notes : This needs some heavy refactoring.
* I thought of actually adding an effect interface class. Every pattern effect
* could then be moved into its own class that inherits from the effect interface.
* If effect handling differs severly between module formats, every format would have
* its own class for that effect. Then, a call chain of effect classes could be set up
* for each format, since effects cannot be processed in the same order in all formats.
* Authors: Olivier Lapicque
* OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Sndfile.h"
#include "mod_specifications.h"
#ifdef MODPLUG_TRACKER
#include "../mptrack/Moddoc.h"
#endif // MODPLUG_TRACKER
#include "tuning.h"
#include "Tables.h"
#include "modsmp_ctrl.h" // For updating the loop wraparound data with the invert loop effect
#include "plugins/PlugInterface.h"
#include "OPL.h"
#include "MIDIEvents.h"
OPENMPT_NAMESPACE_BEGIN
// Formats which have 7-bit (0...128) instead of 6-bit (0...64) global volume commands, or which are imported to this range (mostly formats which are converted to IT internally)
#ifdef MODPLUG_TRACKER
static constexpr auto GLOBALVOL_7BIT_FORMATS_EXT = MOD_TYPE_MT2;
#else
static constexpr auto GLOBALVOL_7BIT_FORMATS_EXT = MOD_TYPE_NONE;
#endif // MODPLUG_TRACKER
static constexpr auto GLOBALVOL_7BIT_FORMATS = MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_IMF | MOD_TYPE_J2B | MOD_TYPE_MID | MOD_TYPE_AMS | MOD_TYPE_DBM | MOD_TYPE_PTM | MOD_TYPE_MDL | MOD_TYPE_DTM | GLOBALVOL_7BIT_FORMATS_EXT;
// Compensate frequency slide LUTs depending on whether we are handling periods or frequency - "up" and "down" in function name are seen from frequency perspective.
static uint32 GetLinearSlideDownTable (const CSoundFile *sndFile, uint32 i) { MPT_ASSERT(i < std::size(LinearSlideDownTable)); return sndFile->m_playBehaviour[kPeriodsAreHertz] ? LinearSlideDownTable[i] : LinearSlideUpTable[i]; }
static uint32 GetLinearSlideUpTable (const CSoundFile *sndFile, uint32 i) { MPT_ASSERT(i < std::size(LinearSlideDownTable)); return sndFile->m_playBehaviour[kPeriodsAreHertz] ? LinearSlideUpTable[i] : LinearSlideDownTable[i]; }
static uint32 GetFineLinearSlideDownTable(const CSoundFile *sndFile, uint32 i) { MPT_ASSERT(i < std::size(FineLinearSlideDownTable)); return sndFile->m_playBehaviour[kPeriodsAreHertz] ? FineLinearSlideDownTable[i] : FineLinearSlideUpTable[i]; }
static uint32 GetFineLinearSlideUpTable (const CSoundFile *sndFile, uint32 i) { MPT_ASSERT(i < std::size(FineLinearSlideDownTable)); return sndFile->m_playBehaviour[kPeriodsAreHertz] ? FineLinearSlideUpTable[i] : FineLinearSlideDownTable[i]; }
////////////////////////////////////////////////////////////
// Length
// Memory class for GetLength() code
class GetLengthMemory
{
protected:
const CSoundFile &sndFile;
public:
std::unique_ptr<CSoundFile::PlayState> state;
struct ChnSettings
{
uint32 ticksToRender = 0; // When using sample sync, we still need to render this many ticks
bool incChanged = false; // When using sample sync, note frequency has changed
uint8 vol = 0xFF;
};
std::vector<ChnSettings> chnSettings;
double elapsedTime;
static constexpr uint32 IGNORE_CHANNEL = uint32_max;
GetLengthMemory(const CSoundFile &sf)
: sndFile(sf)
, state(std::make_unique<CSoundFile::PlayState>(sf.m_PlayState))
{
Reset();
}
void Reset()
{
if(state->m_midiMacroEvaluationResults)
state->m_midiMacroEvaluationResults.emplace();
elapsedTime = 0.0;
state->m_lTotalSampleCount = 0;
state->m_nMusicSpeed = sndFile.m_nDefaultSpeed;
state->m_nMusicTempo = sndFile.m_nDefaultTempo;
state->m_nGlobalVolume = sndFile.m_nDefaultGlobalVolume;
chnSettings.assign(sndFile.GetNumChannels(), ChnSettings());
const auto muteFlag = CSoundFile::GetChannelMuteFlag();
for(CHANNELINDEX chn = 0; chn < sndFile.GetNumChannels(); chn++)
{
state->Chn[chn].Reset(ModChannel::resetTotal, sndFile, chn, muteFlag);
state->Chn[chn].nOldGlobalVolSlide = 0;
state->Chn[chn].nOldChnVolSlide = 0;
state->Chn[chn].nNote = state->Chn[chn].nNewNote = state->Chn[chn].nLastNote = NOTE_NONE;
}
}
// Increment playback position of sample and envelopes on a channel
void RenderChannel(CHANNELINDEX channel, uint32 tickDuration, uint32 portaStart = uint32_max)
{
ModChannel &chn = state->Chn[channel];
uint32 numTicks = chnSettings[channel].ticksToRender;
if(numTicks == IGNORE_CHANNEL || numTicks == 0 || (!chn.IsSamplePlaying() && !chnSettings[channel].incChanged) || chn.pModSample == nullptr)
{
return;
}
const SamplePosition loopStart(chn.dwFlags[CHN_LOOP] ? chn.nLoopStart : 0u, 0);
const SamplePosition sampleEnd(chn.dwFlags[CHN_LOOP] ? chn.nLoopEnd : chn.nLength, 0);
const SmpLength loopLength = chn.nLoopEnd - chn.nLoopStart;
const bool itEnvMode = sndFile.m_playBehaviour[kITEnvelopePositionHandling];
const bool updatePitchEnv = (chn.PitchEnv.flags & (ENV_ENABLED | ENV_FILTER)) == ENV_ENABLED;
bool stopNote = false;
SamplePosition inc = chn.increment * tickDuration;
if(chn.dwFlags[CHN_PINGPONGFLAG]) inc.Negate();
for(uint32 i = 0; i < numTicks; i++)
{
bool updateInc = (chn.PitchEnv.flags & (ENV_ENABLED | ENV_FILTER)) == ENV_ENABLED;
if(i >= portaStart)
{
chn.isFirstTick = false;
const ModCommand &m = *sndFile.Patterns[state->m_nPattern].GetpModCommand(state->m_nRow, channel);
auto command = m.command;
if(m.volcmd == VOLCMD_TONEPORTAMENTO)
{
const auto [porta, clearEffectCommand] = sndFile.GetVolCmdTonePorta(m, 0);
sndFile.TonePortamento(chn, porta);
if(clearEffectCommand)
command = CMD_NONE;
}
if(command == CMD_TONEPORTAMENTO)
sndFile.TonePortamento(chn, m.param);
else if(command == CMD_TONEPORTAVOL)
sndFile.TonePortamento(chn, 0);
updateInc = true;
}
int32 period = chn.nPeriod;
if(itEnvMode) sndFile.IncrementEnvelopePositions(chn);
if(updatePitchEnv)
{
sndFile.ProcessPitchFilterEnvelope(chn, period);
updateInc = true;
}
if(!itEnvMode) sndFile.IncrementEnvelopePositions(chn);
int vol = 0;
sndFile.ProcessInstrumentFade(chn, vol);
if(chn.dwFlags[CHN_ADLIB])
continue;
if(updateInc || chnSettings[channel].incChanged)
{
if(chn.m_CalculateFreq || chn.m_ReCalculateFreqOnFirstTick)
{
chn.RecalcTuningFreq(1, 0, sndFile);
if(!chn.m_CalculateFreq)
chn.m_ReCalculateFreqOnFirstTick = false;
else
chn.m_CalculateFreq = false;
}
chn.increment = sndFile.GetChannelIncrement(chn, period, 0).first;
chnSettings[channel].incChanged = false;
inc = chn.increment * tickDuration;
if(chn.dwFlags[CHN_PINGPONGFLAG]) inc.Negate();
}
chn.position += inc;
if(chn.position >= sampleEnd || (chn.position < loopStart && inc.IsNegative()))
{
if(!chn.dwFlags[CHN_LOOP])
{
// Past sample end.
stopNote = true;
break;
}
// We exceeded the sample loop, go back to loop start.
if(chn.dwFlags[CHN_PINGPONGLOOP])
{
if(chn.position < loopStart)
{
chn.position = SamplePosition(chn.nLoopStart + chn.nLoopStart, 0) - chn.position;
chn.dwFlags.flip(CHN_PINGPONGFLAG);
inc.Negate();
}
SmpLength posInt = chn.position.GetUInt() - chn.nLoopStart;
SmpLength pingpongLength = loopLength * 2;
if(sndFile.m_playBehaviour[kITPingPongMode]) pingpongLength--;
posInt %= pingpongLength;
bool forward = (posInt < loopLength);
if(forward)
chn.position.SetInt(chn.nLoopStart + posInt);
else
chn.position.SetInt(chn.nLoopEnd - (posInt - loopLength));
if(forward == chn.dwFlags[CHN_PINGPONGFLAG])
{
chn.dwFlags.flip(CHN_PINGPONGFLAG);
inc.Negate();
}
} else
{
SmpLength posInt = chn.position.GetUInt();
if(posInt >= chn.nLoopEnd + loopLength)
{
const SmpLength overshoot = posInt - chn.nLoopEnd;
posInt -= (overshoot / loopLength) * loopLength;
}
while(posInt >= chn.nLoopEnd)
{
posInt -= loopLength;
}
chn.position.SetInt(posInt);
}
}
}
if(stopNote)
{
chn.Stop();
chn.nPortamentoDest = 0;
}
chnSettings[channel].ticksToRender = 0;
}
};
// Get mod length in various cases. Parameters:
// [in] adjustMode: See enmGetLengthResetMode for possible adjust modes.
// [in] target: Time or position target which should be reached, or no target to get length of the first sub song. Use GetLengthTarget::StartPos to also specify a position from where the seeking should begin.
// [out] See definition of type GetLengthType for the returned values.
std::vector<GetLengthType> CSoundFile::GetLength(enmGetLengthResetMode adjustMode, GetLengthTarget target)
{
std::vector<GetLengthType> results;
GetLengthType retval;
// Are we trying to reach a certain pattern position?
const bool hasSearchTarget = target.mode != GetLengthTarget::NoTarget && target.mode != GetLengthTarget::GetAllSubsongs;
const bool adjustSamplePos = (adjustMode & eAdjustSamplePositions) == eAdjustSamplePositions;
SEQUENCEINDEX sequence = target.sequence;
if(sequence >= Order.GetNumSequences()) sequence = Order.GetCurrentSequenceIndex();
const ModSequence &orderList = Order(sequence);
GetLengthMemory memory(*this);
CSoundFile::PlayState &playState = *memory.state;
// Temporary visited rows vector (so that GetLength() won't interfere with the player code if the module is playing at the same time)
RowVisitor visitedRows(*this, sequence);
ROWINDEX allowedPatternLoopComplexity = 32768;
// If sequence starts with some non-existent patterns, find a better start
while(target.startOrder < orderList.size() && !orderList.IsValidPat(target.startOrder))
{
target.startOrder++;
target.startRow = 0;
}
retval.startRow = playState.m_nNextRow = playState.m_nRow = target.startRow;
retval.startOrder = playState.m_nNextOrder = playState.m_nCurrentOrder = target.startOrder;
// Fast LUTs for commands that are too weird / complicated / whatever to emulate in sample position adjust mode.
std::bitset<MAX_EFFECTS> forbiddenCommands;
std::bitset<MAX_VOLCMDS> forbiddenVolCommands;
if(adjustSamplePos)
{
forbiddenCommands.set(CMD_ARPEGGIO); forbiddenCommands.set(CMD_PORTAMENTOUP);
forbiddenCommands.set(CMD_PORTAMENTODOWN); forbiddenCommands.set(CMD_XFINEPORTAUPDOWN);
forbiddenCommands.set(CMD_NOTESLIDEUP); forbiddenCommands.set(CMD_NOTESLIDEUPRETRIG);
forbiddenCommands.set(CMD_NOTESLIDEDOWN); forbiddenCommands.set(CMD_NOTESLIDEDOWNRETRIG);
forbiddenVolCommands.set(VOLCMD_PORTAUP); forbiddenVolCommands.set(VOLCMD_PORTADOWN);
if(target.mode == GetLengthTarget::SeekPosition && target.pos.order < orderList.size())
{
// If we know where to seek, we can directly rule out any channels on which a new note would be triggered right at the start.
const PATTERNINDEX seekPat = orderList[target.pos.order];
if(Patterns.IsValidPat(seekPat) && Patterns[seekPat].IsValidRow(target.pos.row))
{
const ModCommand *m = Patterns[seekPat].GetpModCommand(target.pos.row, 0);
for(CHANNELINDEX i = 0; i < GetNumChannels(); i++, m++)
{
if(m->note == NOTE_NOTECUT || m->note == NOTE_KEYOFF || (m->note == NOTE_FADE && GetNumInstruments())
|| (m->IsNote() && !m->IsPortamento()))
{
memory.chnSettings[i].ticksToRender = GetLengthMemory::IGNORE_CHANNEL;
}
}
}
}
}
if(adjustMode & eAdjust)
playState.m_midiMacroEvaluationResults.emplace();
// If samples are being synced, force them to resync if tick duration changes
uint32 oldTickDuration = 0;
bool breakToRow = false;
for (;;)
{
const bool ignoreRow = NextRow(playState, breakToRow).first;
// Time target reached.
if(target.mode == GetLengthTarget::SeekSeconds && memory.elapsedTime >= target.time)
{
retval.targetReached = true;
break;
}
// Check if pattern is valid
playState.m_nPattern = playState.m_nCurrentOrder < orderList.size() ? orderList[playState.m_nCurrentOrder] : orderList.GetInvalidPatIndex();
if(!Patterns.IsValidPat(playState.m_nPattern) && playState.m_nPattern != orderList.GetInvalidPatIndex() && target.mode == GetLengthTarget::SeekPosition && playState.m_nCurrentOrder == target.pos.order)
{
// Early test: Target is inside +++ or non-existing pattern
retval.targetReached = true;
break;
}
while(playState.m_nPattern >= Patterns.Size())
{
// End of song?
if((playState.m_nPattern == orderList.GetInvalidPatIndex()) || (playState.m_nCurrentOrder >= orderList.size()))
{
if(playState.m_nCurrentOrder == orderList.GetRestartPos())
break;
else
playState.m_nCurrentOrder = orderList.GetRestartPos();
} else
{
playState.m_nCurrentOrder++;
}
playState.m_nPattern = (playState.m_nCurrentOrder < orderList.size()) ? orderList[playState.m_nCurrentOrder] : orderList.GetInvalidPatIndex();
playState.m_nNextOrder = playState.m_nCurrentOrder;
if((!Patterns.IsValidPat(playState.m_nPattern)) && visitedRows.Visit(playState.m_nCurrentOrder, 0, playState.Chn, ignoreRow))
{
if(!hasSearchTarget)
{
retval.lastOrder = playState.m_nCurrentOrder;
retval.lastRow = 0;
}
if(target.mode == GetLengthTarget::NoTarget || !visitedRows.GetFirstUnvisitedRow(playState.m_nNextOrder, playState.m_nRow, true))
{
// We aren't searching for a specific row, or we couldn't find any more unvisited rows.
break;
} else
{
// We haven't found the target row yet, but we found some other unplayed row... continue searching from here.
retval.duration = memory.elapsedTime;
results.push_back(retval);
retval.startRow = playState.m_nRow;
retval.startOrder = playState.m_nNextOrder;
memory.Reset();
playState.m_nCurrentOrder = playState.m_nNextOrder;
playState.m_nPattern = orderList[playState.m_nCurrentOrder];
playState.m_nNextRow = playState.m_nRow;
break;
}
}
}
if(playState.m_nNextOrder == ORDERINDEX_INVALID)
{
// GetFirstUnvisitedRow failed, so there is nothing more to play
break;
}
// Skip non-existing patterns
if(!Patterns.IsValidPat(playState.m_nPattern))
{
// If there isn't even a tune, we should probably stop here.
if(playState.m_nCurrentOrder == orderList.GetRestartPos())
{
if(target.mode == GetLengthTarget::NoTarget || !visitedRows.GetFirstUnvisitedRow(playState.m_nNextOrder, playState.m_nRow, true))
{
// We aren't searching for a specific row, or we couldn't find any more unvisited rows.
break;
} else
{
// We haven't found the target row yet, but we found some other unplayed row... continue searching from here.
retval.duration = memory.elapsedTime;
results.push_back(retval);
retval.startRow = playState.m_nRow;
retval.startOrder = playState.m_nNextOrder;
memory.Reset();
playState.m_nNextRow = playState.m_nRow;
continue;
}
}
playState.m_nNextOrder = playState.m_nCurrentOrder + 1;
continue;
}
// Should never happen
if(playState.m_nRow >= Patterns[playState.m_nPattern].GetNumRows())
playState.m_nRow = 0;
// Check whether target was reached.
if(target.mode == GetLengthTarget::SeekPosition && playState.m_nCurrentOrder == target.pos.order && playState.m_nRow == target.pos.row)
{
retval.targetReached = true;
break;
}
// If pattern loops are nested too deeply, they can cause an effectively infinite amount of loop evalations to be generated.
// As we don't want the user to wait forever, we bail out if the pattern loops are too complex.
const bool moduleTooComplex = target.mode != GetLengthTarget::SeekSeconds && visitedRows.ModuleTooComplex(allowedPatternLoopComplexity);
if(moduleTooComplex)
{
memory.elapsedTime = std::numeric_limits<decltype(memory.elapsedTime)>::infinity();
// Decrease allowed complexity with each subsong, as this seems to be a malicious module
if(allowedPatternLoopComplexity > 256)
allowedPatternLoopComplexity /= 2;
visitedRows.ResetComplexity();
}
if(visitedRows.Visit(playState.m_nCurrentOrder, playState.m_nRow, playState.Chn, ignoreRow) || moduleTooComplex)
{
if(!hasSearchTarget)
{
retval.lastOrder = playState.m_nCurrentOrder;
retval.lastRow = playState.m_nRow;
}
if(target.mode == GetLengthTarget::NoTarget || !visitedRows.GetFirstUnvisitedRow(playState.m_nNextOrder, playState.m_nRow, true))
{
// We aren't searching for a specific row, or we couldn't find any more unvisited rows.
break;
} else
{
// We haven't found the target row yet, but we found some other unplayed row... continue searching from here.
retval.duration = memory.elapsedTime;
results.push_back(retval);
retval.startRow = playState.m_nRow;
retval.startOrder = playState.m_nNextOrder;
memory.Reset();
playState.m_nNextRow = playState.m_nRow;
continue;
}
}
retval.endOrder = playState.m_nCurrentOrder;
retval.endRow = playState.m_nRow;
// Update next position
SetupNextRow(playState, false);
// Jumped to invalid pattern row?
if(playState.m_nRow >= Patterns[playState.m_nPattern].GetNumRows())
{
playState.m_nRow = 0;
}
if(ignoreRow)
continue;
// For various effects, we need to know first how many ticks there are in this row.
const ModCommand *p = Patterns[playState.m_nPattern].GetpModCommand(playState.m_nRow, 0);
const bool ignoreMutedChn = m_playBehaviour[kST3NoMutedChannels];
for(CHANNELINDEX nChn = 0; nChn < GetNumChannels(); nChn++, p++)
{
ModChannel &chn = playState.Chn[nChn];
if(p->IsEmpty() || (ignoreMutedChn && ChnSettings[nChn].dwFlags[CHN_MUTE])) // not even effects are processed on muted S3M channels
{
chn.rowCommand.Clear();
continue;
}
if(p->IsPcNote())
{
#ifndef NO_PLUGINS
if(playState.m_midiMacroEvaluationResults && p->instr > 0 && p->instr <= MAX_MIXPLUGINS)
{
playState.m_midiMacroEvaluationResults->pluginParameter[{static_cast<PLUGINDEX>(p->instr - 1), p->GetValueVolCol()}] = p->GetValueEffectCol() / PlugParamValue(ModCommand::maxColumnValue);
}
#endif // NO_PLUGINS
chn.rowCommand.Clear();
continue;
}
chn.rowCommand = *p;
switch(p->command)
{
case CMD_SPEED:
SetSpeed(playState, p->param);
break;
case CMD_TEMPO:
if(m_playBehaviour[kMODVBlankTiming])
{
// ProTracker MODs with VBlank timing: All Fxx parameters set the tick count.
if(p->param != 0) SetSpeed(playState, p->param);
}
break;
case CMD_S3MCMDEX:
if(!chn.rowCommand.param && (GetType() & (MOD_TYPE_S3M | MOD_TYPE_IT | MOD_TYPE_MPT)))
chn.rowCommand.param = chn.nOldCmdEx;
else
chn.nOldCmdEx = static_cast<ModCommand::PARAM>(chn.rowCommand.param);
if((p->param & 0xF0) == 0x60)
{
// Fine Pattern Delay
playState.m_nFrameDelay += (p->param & 0x0F);
} else if((p->param & 0xF0) == 0xE0 && !playState.m_nPatternDelay)
{
// Pattern Delay
if(!(GetType() & MOD_TYPE_S3M) || (p->param & 0x0F) != 0)
{
// While Impulse Tracker *does* count S60 as a valid row delay (and thus ignores any other row delay commands on the right),
// Scream Tracker 3 simply ignores such commands.
playState.m_nPatternDelay = 1 + (p->param & 0x0F);
}
}
break;
case CMD_MODCMDEX:
if((p->param & 0xF0) == 0xE0)
{
// Pattern Delay
playState.m_nPatternDelay = 1 + (p->param & 0x0F);
}
break;
}
}
const uint32 numTicks = playState.TicksOnRow();
const uint32 nonRowTicks = numTicks - std::max(playState.m_nPatternDelay, uint32(1));
playState.m_patLoopRow = ROWINDEX_INVALID;
playState.m_breakRow = ROWINDEX_INVALID;
playState.m_posJump = ORDERINDEX_INVALID;
for(CHANNELINDEX nChn = 0; nChn < GetNumChannels(); nChn++)
{
ModChannel &chn = playState.Chn[nChn];
if(chn.rowCommand.IsEmpty())
continue;
ModCommand::COMMAND command = chn.rowCommand.command;
ModCommand::PARAM param = chn.rowCommand.param;
ModCommand::NOTE note = chn.rowCommand.note;
if(adjustMode & eAdjust)
{
if(chn.rowCommand.instr)
{
chn.nNewIns = chn.rowCommand.instr;
chn.nLastNote = NOTE_NONE;
memory.chnSettings[nChn].vol = 0xFF;
}
if(chn.rowCommand.IsNote())
{
chn.nLastNote = note;
chn.RestorePanAndFilter();
}
// Update channel panning
if(chn.rowCommand.IsNote() || chn.rowCommand.instr)
{
ModInstrument *pIns;
if(chn.nNewIns > 0 && chn.nNewIns <= GetNumInstruments() && (pIns = Instruments[chn.nNewIns]) != nullptr)
{
if(pIns->dwFlags[INS_SETPANNING])
chn.SetInstrumentPan(pIns->nPan, *this);
}
const SAMPLEINDEX smp = GetSampleIndex(note, chn.nNewIns);
if(smp > 0)
{
if(Samples[smp].uFlags[CHN_PANNING])
chn.SetInstrumentPan(Samples[smp].nPan, *this);
}
}
switch(chn.rowCommand.volcmd)
{
case VOLCMD_VOLUME:
memory.chnSettings[nChn].vol = chn.rowCommand.vol;
break;
case VOLCMD_VOLSLIDEUP:
case VOLCMD_VOLSLIDEDOWN:
if(chn.rowCommand.vol != 0)
chn.nOldVolParam = chn.rowCommand.vol;
break;
case VOLCMD_TONEPORTAMENTO:
if(chn.rowCommand.vol)
{
const auto [porta, clearEffectCommand] = GetVolCmdTonePorta(chn.rowCommand, 0);
chn.portamentoSlide = porta;
if(clearEffectCommand)
command = CMD_NONE;
}
break;
}
}
switch(command)
{
// Position Jump
case CMD_POSITIONJUMP:
PositionJump(playState, nChn);
break;
// Pattern Break
case CMD_PATTERNBREAK:
if(ROWINDEX row = PatternBreak(playState, nChn, param); row != ROWINDEX_INVALID)
playState.m_breakRow = row;
break;
// Set Tempo
case CMD_TEMPO:
if(!m_playBehaviour[kMODVBlankTiming])
{
TEMPO tempo(CalculateXParam(playState.m_nPattern, playState.m_nRow, nChn), 0);
if ((adjustMode & eAdjust) && (GetType() & (MOD_TYPE_S3M | MOD_TYPE_IT | MOD_TYPE_MPT)))
{
if (tempo.GetInt()) chn.nOldTempo = static_cast<uint8>(tempo.GetInt()); else tempo.Set(chn.nOldTempo);
}
if (tempo.GetInt() >= 0x20) playState.m_nMusicTempo = tempo;
else
{
// Tempo Slide
TEMPO tempoDiff((tempo.GetInt() & 0x0F) * nonRowTicks, 0);
if ((tempo.GetInt() & 0xF0) == 0x10)
{
playState.m_nMusicTempo += tempoDiff;
} else
{
if(tempoDiff < playState.m_nMusicTempo)
playState.m_nMusicTempo -= tempoDiff;
else
playState.m_nMusicTempo.Set(0);
}
}
TEMPO tempoMin = GetModSpecifications().GetTempoMin(), tempoMax = GetModSpecifications().GetTempoMax();
if(m_playBehaviour[kTempoClamp]) // clamp tempo correctly in compatible mode
{
tempoMax.Set(255);
}
Limit(playState.m_nMusicTempo, tempoMin, tempoMax);
}
break;
case CMD_S3MCMDEX:
switch(param & 0xF0)
{
case 0x90:
if(param <= 0x91)
chn.dwFlags.set(CHN_SURROUND, param == 0x91);
break;
case 0xA0: // High sample offset
chn.nOldHiOffset = param & 0x0F;
break;
case 0xB0: // Pattern Loop
PatternLoop(playState, chn, param & 0x0F);
break;
case 0xF0: // Active macro
chn.nActiveMacro = param & 0x0F;
break;
}
break;
case CMD_MODCMDEX:
switch(param & 0xF0)
{
case 0x60: // Pattern Loop
PatternLoop(playState, chn, param & 0x0F);
break;
case 0xF0: // Active macro
chn.nActiveMacro = param & 0x0F;
break;
}
break;
case CMD_XFINEPORTAUPDOWN:
// ignore high offset in compatible mode
if(((param & 0xF0) == 0xA0) && !m_playBehaviour[kFT2RestrictXCommand])
chn.nOldHiOffset = param & 0x0F;
break;
}
// The following calculations are not interesting if we just want to get the song length.
if(!(adjustMode & eAdjust))
continue;
switch(command)
{
// Portamento Up/Down
case CMD_PORTAMENTOUP:
if(param)
{
// FT2 compatibility: Separate effect memory for all portamento commands
// Test case: Porta-LinkMem.xm
if(!m_playBehaviour[kFT2PortaUpDownMemory])
chn.nOldPortaDown = param;
chn.nOldPortaUp = param;
}
break;
case CMD_PORTAMENTODOWN:
if(param)
{
// FT2 compatibility: Separate effect memory for all portamento commands
// Test case: Porta-LinkMem.xm
if(!m_playBehaviour[kFT2PortaUpDownMemory])
chn.nOldPortaUp = param;
chn.nOldPortaDown = param;
}
break;
// Tone-Portamento
case CMD_TONEPORTAMENTO:
if (param) chn.portamentoSlide = param;
break;
// Offset
case CMD_OFFSET:
if(param)
chn.oldOffset = param << 8;
break;
// Volume Slide
case CMD_VOLUMESLIDE:
case CMD_TONEPORTAVOL:
if (param) chn.nOldVolumeSlide = param;
break;
// Set Volume
case CMD_VOLUME:
memory.chnSettings[nChn].vol = param;
break;
// Global Volume
case CMD_GLOBALVOLUME:
if(!(GetType() & GLOBALVOL_7BIT_FORMATS) && param < 128) param *= 2;
// IT compatibility 16. ST3 and IT ignore out-of-range values
if(param <= 128)
{
playState.m_nGlobalVolume = param * 2;
} else if(!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_S3M)))
{
playState.m_nGlobalVolume = 256;
}
break;
// Global Volume Slide
case CMD_GLOBALVOLSLIDE:
if(m_playBehaviour[kPerChannelGlobalVolSlide])
{
// IT compatibility 16. Global volume slide params are stored per channel (FT2/IT)
if (param) chn.nOldGlobalVolSlide = param; else param = chn.nOldGlobalVolSlide;
} else
{
if (param) playState.Chn[0].nOldGlobalVolSlide = param; else param = playState.Chn[0].nOldGlobalVolSlide;
}
if (((param & 0x0F) == 0x0F) && (param & 0xF0))
{
param >>= 4;
if (!(GetType() & GLOBALVOL_7BIT_FORMATS)) param <<= 1;
playState.m_nGlobalVolume += param << 1;
} else if (((param & 0xF0) == 0xF0) && (param & 0x0F))
{
param = (param & 0x0F) << 1;
if (!(GetType() & GLOBALVOL_7BIT_FORMATS)) param <<= 1;
playState.m_nGlobalVolume -= param;
} else if (param & 0xF0)
{
param >>= 4;
param <<= 1;
if (!(GetType() & GLOBALVOL_7BIT_FORMATS)) param <<= 1;
playState.m_nGlobalVolume += param * nonRowTicks;
} else
{
param = (param & 0x0F) << 1;
if (!(GetType() & GLOBALVOL_7BIT_FORMATS)) param <<= 1;
playState.m_nGlobalVolume -= param * nonRowTicks;
}
Limit(playState.m_nGlobalVolume, 0, 256);
break;
case CMD_CHANNELVOLUME:
if (param <= 64) chn.nGlobalVol = param;
break;
case CMD_CHANNELVOLSLIDE:
{
if (param) chn.nOldChnVolSlide = param; else param = chn.nOldChnVolSlide;
int32 volume = chn.nGlobalVol;
if((param & 0x0F) == 0x0F && (param & 0xF0))
volume += (param >> 4); // Fine Up
else if((param & 0xF0) == 0xF0 && (param & 0x0F))
volume -= (param & 0x0F); // Fine Down
else if(param & 0x0F) // Down
volume -= (param & 0x0F) * nonRowTicks;
else // Up
volume += ((param & 0xF0) >> 4) * nonRowTicks;
Limit(volume, 0, 64);
chn.nGlobalVol = volume;
}
break;
case CMD_PANNING8:
Panning(chn, param, Pan8bit);
break;
case CMD_MODCMDEX:
if(param < 0x10)
{
// LED filter
for(CHANNELINDEX channel = 0; channel < GetNumChannels(); channel++)
{
playState.Chn[channel].dwFlags.set(CHN_AMIGAFILTER, !(param & 1));
}
}
[[fallthrough]];
case CMD_S3MCMDEX:
if((param & 0xF0) == 0x80)
{
Panning(chn, (param & 0x0F), Pan4bit);
}
break;
case CMD_VIBRATOVOL:
if (param) chn.nOldVolumeSlide = param;
param = 0;
[[fallthrough]];
case CMD_VIBRATO:
Vibrato(chn, param);
break;
case CMD_FINEVIBRATO:
FineVibrato(chn, param);
break;
case CMD_TREMOLO:
Tremolo(chn, param);
break;
case CMD_PANBRELLO:
Panbrello(chn, param);
break;
case CMD_MIDI:
case CMD_SMOOTHMIDI:
if(param < 0x80)
ProcessMIDIMacro(playState, nChn, false, m_MidiCfg.SFx[chn.nActiveMacro], chn.rowCommand.param, 0);
else
ProcessMIDIMacro(playState, nChn, false, m_MidiCfg.Zxx[param & 0x7F], chn.rowCommand.param, 0);
break;
default:
break;
}
switch(chn.rowCommand.volcmd)
{
case VOLCMD_PANNING:
Panning(chn, chn.rowCommand.vol, Pan6bit);
break;
case VOLCMD_VIBRATOSPEED:
// FT2 does not automatically enable vibrato with the "set vibrato speed" command
if(m_playBehaviour[kFT2VolColVibrato])
chn.nVibratoSpeed = chn.rowCommand.vol & 0x0F;
else
Vibrato(chn, chn.rowCommand.vol << 4);
break;
case VOLCMD_VIBRATODEPTH:
Vibrato(chn, chn.rowCommand.vol);
break;
}
// Process vibrato / tremolo / panbrello
switch(chn.rowCommand.command)
{
case CMD_VIBRATO:
case CMD_FINEVIBRATO:
case CMD_VIBRATOVOL:
if(adjustMode & eAdjust)
{
uint32 vibTicks = ((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && !m_SongFlags[SONG_ITOLDEFFECTS]) ? numTicks : nonRowTicks;
uint32 inc = chn.nVibratoSpeed * vibTicks;
if(m_playBehaviour[kITVibratoTremoloPanbrello])
inc *= 4;
chn.nVibratoPos += static_cast<uint8>(inc);
}
break;
case CMD_TREMOLO:
if(adjustMode & eAdjust)
{
uint32 tremTicks = ((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && !m_SongFlags[SONG_ITOLDEFFECTS]) ? numTicks : nonRowTicks;
uint32 inc = chn.nTremoloSpeed * tremTicks;
if(m_playBehaviour[kITVibratoTremoloPanbrello])
inc *= 4;
chn.nTremoloPos += static_cast<uint8>(inc);
}
break;
case CMD_PANBRELLO:
if(adjustMode & eAdjust)
{
// Panbrello effect is permanent in compatible mode, so actually apply panbrello for the last tick of this row
chn.nPanbrelloPos += static_cast<uint8>(chn.nPanbrelloSpeed * (numTicks - 1));
ProcessPanbrello(chn);
}
break;
}
if(m_playBehaviour[kST3EffectMemory] && param != 0)
{
UpdateS3MEffectMemory(chn, param);
}
}
// Interpret F00 effect in XM files as "stop song"
if(GetType() == MOD_TYPE_XM && playState.m_nMusicSpeed == uint16_max)
{
break;
}
playState.m_nCurrentRowsPerBeat = m_nDefaultRowsPerBeat;
if(Patterns[playState.m_nPattern].GetOverrideSignature())
{
playState.m_nCurrentRowsPerBeat = Patterns[playState.m_nPattern].GetRowsPerBeat();
}
const uint32 tickDuration = GetTickDuration(playState);
const uint32 rowDuration = tickDuration * numTicks;
memory.elapsedTime += static_cast<double>(rowDuration) / static_cast<double>(m_MixerSettings.gdwMixingFreq);
playState.m_lTotalSampleCount += rowDuration;
if(adjustSamplePos)
{
// Super experimental and dirty sample seeking
for(CHANNELINDEX nChn = 0; nChn < GetNumChannels(); nChn++)
{
if(memory.chnSettings[nChn].ticksToRender == GetLengthMemory::IGNORE_CHANNEL)
continue;
ModChannel &chn = playState.Chn[nChn];
const ModCommand &m = chn.rowCommand;
if(!chn.nPeriod && m.IsEmpty())
continue;
uint32 paramHi = m.param >> 4, paramLo = m.param & 0x0F;
uint32 startTick = 0;
bool porta = m.command == CMD_TONEPORTAMENTO || m.command == CMD_TONEPORTAVOL || m.volcmd == VOLCMD_TONEPORTAMENTO;
bool stopNote = false;
if(m.instr) chn.prevNoteOffset = 0;
if(m.IsNote())
{
if(porta && memory.chnSettings[nChn].incChanged)
{
// If there's a portamento, the current channel increment mustn't be 0 in NoteChange()
chn.increment = GetChannelIncrement(chn, chn.nPeriod, 0).first;
}
int32 setPan = chn.nPan;
chn.nNewNote = chn.nLastNote;
if(chn.nNewIns != 0) InstrumentChange(chn, chn.nNewIns, porta);
NoteChange(chn, m.note, porta);
HandleDigiSamplePlayDirection(playState, nChn);
memory.chnSettings[nChn].incChanged = true;
if((m.command == CMD_MODCMDEX || m.command == CMD_S3MCMDEX) && (m.param & 0xF0) == 0xD0 && paramLo < numTicks)
{
startTick = paramLo;
} else if(m.command == CMD_DELAYCUT && paramHi < numTicks)
{
startTick = paramHi;
}
if(playState.m_nPatternDelay > 1 && startTick != 0 && (GetType() & (MOD_TYPE_S3M | MOD_TYPE_IT | MOD_TYPE_MPT)))
{
startTick += (playState.m_nMusicSpeed + playState.m_nFrameDelay) * (playState.m_nPatternDelay - 1);
}
if(!porta) memory.chnSettings[nChn].ticksToRender = 0;
// Panning commands have to be re-applied after a note change with potential pan change.
if(m.command == CMD_PANNING8
|| ((m.command == CMD_MODCMDEX || m.command == CMD_S3MCMDEX) && paramHi == 0x8)
|| m.volcmd == VOLCMD_PANNING)
{
chn.nPan = setPan;
}
}
if(m.IsNote() || m_playBehaviour[kApplyOffsetWithoutNote])
{
if(m.command == CMD_OFFSET)
{
ProcessSampleOffset(chn, nChn, playState);
} else if(m.command == CMD_OFFSETPERCENTAGE)
{
SampleOffset(chn, Util::muldiv_unsigned(chn.nLength, m.param, 256));
} else if(m.command == CMD_REVERSEOFFSET && chn.pModSample != nullptr)
{
memory.RenderChannel(nChn, oldTickDuration); // Re-sync what we've got so far
ReverseSampleOffset(chn, m.param);
startTick = playState.m_nMusicSpeed - 1;
} else if(m.volcmd == VOLCMD_OFFSET)
{
if(chn.pModSample != nullptr && m.vol <= std::size(chn.pModSample->cues))
{
SmpLength offset;
if(m.vol == 0)
offset = chn.oldOffset;
else
offset = chn.oldOffset = chn.pModSample->cues[m.vol - 1];
SampleOffset(chn, offset);
}
}
}
if(m.note == NOTE_KEYOFF || m.note == NOTE_NOTECUT || (m.note == NOTE_FADE && GetNumInstruments())
|| ((m.command == CMD_MODCMDEX || m.command == CMD_S3MCMDEX) && (m.param & 0xF0) == 0xC0 && paramLo < numTicks)
|| (m.command == CMD_DELAYCUT && paramLo != 0 && startTick + paramLo < numTicks)
|| m.command == CMD_KEYOFF)
{
stopNote = true;
}
if(m.command == CMD_VOLUME)
{
chn.nVolume = m.param * 4;
} else if(m.volcmd == VOLCMD_VOLUME)
{
chn.nVolume = m.vol * 4;
}
if(chn.pModSample && !stopNote)
{
// Check if we don't want to emulate some effect and thus stop processing.
if(m.command < MAX_EFFECTS)
{
if(forbiddenCommands[m.command])
{
stopNote = true;
} else if(m.command == CMD_MODCMDEX)
{
// Special case: Slides using extended commands
switch(m.param & 0xF0)
{
case 0x10:
case 0x20:
stopNote = true;
}
}
}
if(m.volcmd < forbiddenVolCommands.size() && forbiddenVolCommands[m.volcmd])
{
stopNote = true;
}
}
if(stopNote)
{
chn.Stop();
memory.chnSettings[nChn].ticksToRender = 0;
} else
{
if(oldTickDuration != tickDuration && oldTickDuration != 0)
{
memory.RenderChannel(nChn, oldTickDuration); // Re-sync what we've got so far
}
switch(m.command)
{
case CMD_TONEPORTAVOL:
case CMD_VOLUMESLIDE:
case CMD_VIBRATOVOL:
if(m.param || (GetType() != MOD_TYPE_MOD))
{
for(uint32 i = 0; i < numTicks; i++)
{
chn.isFirstTick = (i == 0);
VolumeSlide(chn, m.param);
}
}
break;
case CMD_MODCMDEX:
if((m.param & 0x0F) || (GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2)))
{
chn.isFirstTick = true;
switch(m.param & 0xF0)
{
case 0xA0: FineVolumeUp(chn, m.param & 0x0F, false); break;
case 0xB0: FineVolumeDown(chn, m.param & 0x0F, false); break;
}
}
break;
case CMD_S3MCMDEX:
if(m.param == 0x9E)
{
// Play forward
memory.RenderChannel(nChn, oldTickDuration); // Re-sync what we've got so far
chn.dwFlags.reset(CHN_PINGPONGFLAG);
} else if(m.param == 0x9F)
{
// Reverse
memory.RenderChannel(nChn, oldTickDuration); // Re-sync what we've got so far
chn.dwFlags.set(CHN_PINGPONGFLAG);
if(!chn.position.GetInt() && chn.nLength && (m.IsNote() || !chn.dwFlags[CHN_LOOP]))
{
chn.position.Set(chn.nLength - 1, SamplePosition::fractMax);
}
} else if((m.param & 0xF0) == 0x70)
{
if(m.param >= 0x73)
chn.InstrumentControl(m.param, *this);
}
break;
case CMD_DIGIREVERSESAMPLE:
DigiBoosterSampleReverse(chn, m.param);
break;
case CMD_FINETUNE:
case CMD_FINETUNE_SMOOTH:
memory.RenderChannel(nChn, oldTickDuration); // Re-sync what we've got so far
SetFinetune(nChn, playState, false); // TODO should render each tick individually for CMD_FINETUNE_SMOOTH for higher sync accuracy
break;
}
chn.isFirstTick = true;
switch(m.volcmd)
{
case VOLCMD_FINEVOLUP: FineVolumeUp(chn, m.vol, m_playBehaviour[kITVolColMemory]); break;
case VOLCMD_FINEVOLDOWN: FineVolumeDown(chn, m.vol, m_playBehaviour[kITVolColMemory]); break;
case VOLCMD_VOLSLIDEUP:
case VOLCMD_VOLSLIDEDOWN:
{
// IT Compatibility: Volume column volume slides have their own memory
// Test case: VolColMemory.it
ModCommand::VOL vol = m.vol;
if(vol == 0 && m_playBehaviour[kITVolColMemory])
{
vol = chn.nOldVolParam;
if(vol == 0)
break;
}
if(m.volcmd == VOLCMD_VOLSLIDEUP)
vol <<= 4;
for(uint32 i = 0; i < numTicks; i++)
{
chn.isFirstTick = (i == 0);
VolumeSlide(chn, vol);
}
}
break;
case VOLCMD_PLAYCONTROL:
if(m.vol <= 1)
chn.isPaused = (m.vol == 0);
break;
}
if(chn.isPaused)
continue;
if(porta)
{
// Portamento needs immediate syncing, as the pitch changes on each tick
uint32 portaTick = memory.chnSettings[nChn].ticksToRender + startTick + 1;
memory.chnSettings[nChn].ticksToRender += numTicks;
memory.RenderChannel(nChn, tickDuration, portaTick);
} else
{
memory.chnSettings[nChn].ticksToRender += (numTicks - startTick);
}
}
}
}
oldTickDuration = tickDuration;
breakToRow = HandleNextRow(playState, orderList, false);
}
// Now advance the sample positions for sample seeking on channels that are still playing
if(adjustSamplePos)
{
for(CHANNELINDEX nChn = 0; nChn < GetNumChannels(); nChn++)
{
if(memory.chnSettings[nChn].ticksToRender != GetLengthMemory::IGNORE_CHANNEL)
{
memory.RenderChannel(nChn, oldTickDuration);
}
}
}
if(retval.targetReached)
{
retval.lastOrder = playState.m_nCurrentOrder;
retval.lastRow = playState.m_nRow;
}
retval.duration = memory.elapsedTime;
results.push_back(retval);
// Store final variables
if(adjustMode & eAdjust)
{
if(retval.targetReached || target.mode == GetLengthTarget::NoTarget)
{
const auto midiMacroEvaluationResults = std::move(playState.m_midiMacroEvaluationResults);
playState.m_midiMacroEvaluationResults.reset();
// Target found, or there is no target (i.e. play whole song)...
m_PlayState = std::move(playState);
m_PlayState.ResetGlobalVolumeRamping();
m_PlayState.m_nNextRow = m_PlayState.m_nRow;
m_PlayState.m_nFrameDelay = m_PlayState.m_nPatternDelay = 0;
m_PlayState.m_nTickCount = TICKS_ROW_FINISHED;
m_PlayState.m_bPositionChanged = true;
if(m_opl != nullptr)
m_opl->Reset();
for(CHANNELINDEX n = 0; n < GetNumChannels(); n++)
{
auto &chn = m_PlayState.Chn[n];
if(chn.nLastNote != NOTE_NONE)
{
chn.nNewNote = chn.nLastNote;
}
if(memory.chnSettings[n].vol != 0xFF && !adjustSamplePos)
{
chn.nVolume = std::min(memory.chnSettings[n].vol, uint8(64)) * 4;
}
if(chn.pModSample != nullptr && chn.pModSample->uFlags[CHN_ADLIB] && m_opl)
{
m_opl->Patch(n, chn.pModSample->adlib);
m_opl->NoteCut(n);
}
chn.pCurrentSample = nullptr;
}
#ifndef NO_PLUGINS
// If there were any PC events or MIDI macros updating plugin parameters, update plugin parameters to their latest value.
std::bitset<MAX_MIXPLUGINS> plugSetProgram;
for(const auto &[plugParam, value] : midiMacroEvaluationResults->pluginParameter)
{
PLUGINDEX plug = plugParam.first;
IMixPlugin *plugin = m_MixPlugins[plug].pMixPlugin;
if(plugin != nullptr)
{
if(!plugSetProgram[plug])
{
// Used for bridged plugins to avoid sending out individual messages for each parameter.
plugSetProgram.set(plug);
plugin->BeginSetProgram();
}
plugin->SetParameter(plugParam.second, value);
}
}
if(plugSetProgram.any())
{
for(PLUGINDEX i = 0; i < MAX_MIXPLUGINS; i++)
{
if(plugSetProgram[i])
{
m_MixPlugins[i].pMixPlugin->EndSetProgram();
}
}
}
// Do the same for dry/wet ratios
for(const auto &[plug, dryWetRatio] : midiMacroEvaluationResults->pluginDryWetRatio)
{
m_MixPlugins[plug].fDryRatio = dryWetRatio;
}
#endif // NO_PLUGINS
} else if(adjustMode != eAdjustOnSuccess)
{
// Target not found (e.g. when jumping to a hidden sub song), reset global variables...
m_PlayState.m_nMusicSpeed = m_nDefaultSpeed;
m_PlayState.m_nMusicTempo = m_nDefaultTempo;
m_PlayState.m_nGlobalVolume = m_nDefaultGlobalVolume;
}
// When adjusting the playback status, we will also want to update the visited rows vector according to the current position.
if(sequence != Order.GetCurrentSequenceIndex())
{
Order.SetSequence(sequence);
}
}
if(adjustMode & (eAdjust | eAdjustOnlyVisitedRows))
m_visitedRows.MoveVisitedRowsFrom(visitedRows);
return results;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
// Effects
// Change sample or instrument number.
void CSoundFile::InstrumentChange(ModChannel &chn, uint32 instr, bool bPorta, bool bUpdVol, bool bResetEnv) const
{
const ModInstrument *pIns = instr <= GetNumInstruments() ? Instruments[instr] : nullptr;
const ModSample *pSmp = &Samples[instr];
const auto oldInsVol = chn.nInsVol;
ModCommand::NOTE note = chn.nNewNote;
if(note == NOTE_NONE && m_playBehaviour[kITInstrWithoutNote]) return;
if(pIns != nullptr && ModCommand::IsNote(note))
{
// Impulse Tracker ignores empty slots.
// We won't ignore them if a plugin is assigned to this slot, so that VSTis still work as intended.
// Test case: emptyslot.it, PortaInsNum.it, gxsmp.it, gxsmp2.it
if(pIns->Keyboard[note - NOTE_MIN] == 0 && m_playBehaviour[kITEmptyNoteMapSlot] && !pIns->HasValidMIDIChannel())
{
chn.pModInstrument = pIns;
return;
}
if(pIns->NoteMap[note - NOTE_MIN] > NOTE_MAX) return;
uint32 n = pIns->Keyboard[note - NOTE_MIN];
pSmp = ((n) && (n < MAX_SAMPLES)) ? &Samples[n] : nullptr;
} else if(GetNumInstruments())
{
// No valid instrument, or not a valid note.
if (note >= NOTE_MIN_SPECIAL) return;
if(m_playBehaviour[kITEmptyNoteMapSlot] && (pIns == nullptr || !pIns->HasValidMIDIChannel()))
{
// Impulse Tracker ignores empty slots.
// We won't ignore them if a plugin is assigned to this slot, so that VSTis still work as intended.
// Test case: emptyslot.it, PortaInsNum.it, gxsmp.it, gxsmp2.it
chn.pModInstrument = nullptr;
chn.nNewIns = 0;
return;
}
pSmp = nullptr;
}
bool returnAfterVolumeAdjust = false;
// instrumentChanged is used for IT carry-on env option
bool instrumentChanged = (pIns != chn.pModInstrument);
const bool sampleChanged = (chn.pModSample != nullptr) && (pSmp != chn.pModSample);
const bool newTuning = (GetType() == MOD_TYPE_MPT && pIns && pIns->pTuning);
if(!bPorta || instrumentChanged || sampleChanged)
chn.microTuning = 0;
// Playback behavior change for MPT: With portamento don't change sample if it is in
// the same instrument as previous sample.
if(bPorta && newTuning && pIns == chn.pModInstrument && sampleChanged)
return;
if(sampleChanged && bPorta)
{
// IT compatibility: No sample change (also within multi-sample instruments) during portamento when using Compatible Gxx.
// Test case: PortaInsNumCompat.it, PortaSampleCompat.it, PortaCutCompat.it
if(m_playBehaviour[kITPortamentoInstrument] && m_SongFlags[SONG_ITCOMPATGXX] && !chn.increment.IsZero())
{
pSmp = chn.pModSample;
}
// Special XM hack (also applies to MOD / S3M, except when playing IT-style S3Ms, such as k_vision.s3m)
// Test case: PortaSmpChange.mod, PortaSmpChange.s3m, PortaSwap.s3m
if((!instrumentChanged && (GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2)) && pIns)
|| (GetType() == MOD_TYPE_PLM)
|| (GetType() == MOD_TYPE_MOD && chn.IsSamplePlaying())
|| (m_playBehaviour[kST3PortaSampleChange] && chn.IsSamplePlaying()))
{
// FT2 doesn't change the sample in this case,
// but still uses the sample info from the old one (bug?)
returnAfterVolumeAdjust = true;
}
}
// IT compatibility: A lone instrument number should only reset sample properties to those of the corresponding sample in instrument mode.
// C#5 01 ... <-- sample 1
// C-5 .. g02 <-- sample 2
// ... 01 ... <-- still sample 1, but with properties of sample 2
// In the above example, no sample change happens on the second row. In the third row, sample 1 keeps playing but with the
// volume and panning properties of sample 2.
// Test case: InstrAfterMultisamplePorta.it
if(m_nInstruments && !instrumentChanged && sampleChanged && chn.pCurrentSample != nullptr && m_playBehaviour[kITMultiSampleInstrumentNumber] && !chn.rowCommand.IsNote())
{
returnAfterVolumeAdjust = true;
}
// IT Compatibility: Envelope pickup after SCx cut (but don't do this when working with plugins, or else envelope carry stops working)
// Test case: cut-carry.it
if(!chn.IsSamplePlaying() && (GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && (!pIns || !pIns->HasValidMIDIChannel()))
{
instrumentChanged = true;
}
// FT2 compatibility: new instrument + portamento = ignore new instrument number, but reload old instrument settings (the world of XM is upside down...)
// And this does *not* happen if volume column portamento is used together with note delay... (handled in ProcessEffects(), where all the other note delay stuff is.)
// Test case: porta-delay.xm, SamplePortaInInstrument.xm
if((instrumentChanged || sampleChanged) && bPorta && m_playBehaviour[kFT2PortaIgnoreInstr] && (chn.pModInstrument != nullptr || chn.pModSample != nullptr))
{
pIns = chn.pModInstrument;
pSmp = chn.pModSample;
instrumentChanged = false;
} else
{
chn.pModInstrument = pIns;
}
// Update Volume
if (bUpdVol && (!(GetType() & (MOD_TYPE_MOD | MOD_TYPE_S3M)) || ((pSmp != nullptr && pSmp->HasSampleData()) || chn.HasMIDIOutput())))
{
if(pSmp)
{
if(!pSmp->uFlags[SMP_NODEFAULTVOLUME])
chn.nVolume = pSmp->nVolume;
} else if(pIns && pIns->nMixPlug)
{
chn.nVolume = chn.GetVSTVolume();
} else
{
chn.nVolume = 0;
}
}
if(returnAfterVolumeAdjust && sampleChanged && pSmp != nullptr)
{
// ProTracker applies new instrument's finetune but keeps the old sample playing.
// Test case: PortaSwapPT.mod
if(m_playBehaviour[kMODSampleSwap])
chn.nFineTune = pSmp->nFineTune;
// ST3 does it similarly for middle-C speed.
// Test case: PortaSwap.s3m, SampleSwap.s3m
if(GetType() == MOD_TYPE_S3M && pSmp->HasSampleData())
chn.nC5Speed = pSmp->nC5Speed;
}
if(returnAfterVolumeAdjust) return;
// Instrument adjust
chn.nNewIns = 0;
// IT Compatiblity: NNA is reset on every note change, not every instrument change (fixes s7xinsnum.it).
if (pIns && ((!m_playBehaviour[kITNNAReset] && pSmp) || pIns->nMixPlug || instrumentChanged))
chn.nNNA = pIns->nNNA;
// Update volume
chn.UpdateInstrumentVolume(pSmp, pIns);
// Update panning
// FT2 compatibility: Only reset panning on instrument numbers, not notes (bUpdVol condition)
// Test case: PanMemory.xm
// IT compatibility: Sample and instrument panning is only applied on note change, not instrument change
// Test case: PanReset.it
if((bUpdVol || !(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2))) && !m_playBehaviour[kITPanningReset])
{
ApplyInstrumentPanning(chn, pIns, pSmp);
}
// Reset envelopes
if(bResetEnv)
{
// Blurb by Storlek (from the SchismTracker code):
// Conditions experimentally determined to cause envelope reset in Impulse Tracker:
// - no note currently playing (of course)
// - note given, no portamento
// - instrument number given, portamento, compat gxx enabled
// - instrument number given, no portamento, after keyoff, old effects enabled
// If someone can enlighten me to what the logic really is here, I'd appreciate it.
// Seems like it's just a total mess though, probably to get XMs to play right.
bool reset, resetAlways;
// IT Compatibility: Envelope reset
// Test case: EnvReset.it
if(m_playBehaviour[kITEnvelopeReset])
{
const bool insNumber = (instr != 0);
reset = (!chn.nLength
|| (insNumber && bPorta && m_SongFlags[SONG_ITCOMPATGXX])
|| (insNumber && !bPorta && chn.dwFlags[CHN_NOTEFADE | CHN_KEYOFF] && m_SongFlags[SONG_ITOLDEFFECTS]));
// NOTE: IT2.14 with SB/GUS/etc. output is different. We are going after IT's WAV writer here.
// For SB/GUS/etc. emulation, envelope carry should only apply when the NNA isn't set to "Note Cut".
// Test case: CarryNNA.it
resetAlways = (!chn.nFadeOutVol || instrumentChanged || chn.dwFlags[CHN_KEYOFF]);
} else
{
reset = (!bPorta || !(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_DBM)) || m_SongFlags[SONG_ITCOMPATGXX]
|| !chn.nLength || (chn.dwFlags[CHN_NOTEFADE] && !chn.nFadeOutVol));
resetAlways = !(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_DBM)) || instrumentChanged || pIns == nullptr || chn.dwFlags[CHN_KEYOFF | CHN_NOTEFADE];
}
if(reset)
{
chn.dwFlags.set(CHN_FASTVOLRAMP);
if(pIns != nullptr)
{
if(resetAlways)
{
chn.ResetEnvelopes();
} else
{
if(!pIns->VolEnv.dwFlags[ENV_CARRY]) chn.VolEnv.Reset();
if(!pIns->PanEnv.dwFlags[ENV_CARRY]) chn.PanEnv.Reset();
if(!pIns->PitchEnv.dwFlags[ENV_CARRY]) chn.PitchEnv.Reset();
}
}
// IT Compatibility: Autovibrato reset
if(!m_playBehaviour[kITVibratoTremoloPanbrello])
{
chn.nAutoVibDepth = 0;
chn.nAutoVibPos = 0;
}
} else if(pIns != nullptr && !pIns->VolEnv.dwFlags[ENV_ENABLED])
{
if(m_playBehaviour[kITPortamentoInstrument])
{
chn.VolEnv.Reset();
} else
{
chn.ResetEnvelopes();
}
}
}
// Invalid sample ?
if(pSmp == nullptr && (pIns == nullptr || !pIns->HasValidMIDIChannel()))
{
chn.pModSample = nullptr;
chn.nInsVol = 0;
return;
}
// Tone-Portamento doesn't reset the pingpong direction flag
if(bPorta && pSmp == chn.pModSample && pSmp != nullptr)
{
// If channel length is 0, we cut a previous sample using SCx. In that case, we have to update sample length, loop points, etc...
if(GetType() & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT) && chn.nLength != 0)
return;
// FT2 compatibility: Do not reset key-off status on portamento without instrument number
// Test case: Off-Porta.xm
if(GetType() != MOD_TYPE_XM || !m_playBehaviour[kITFT2DontResetNoteOffOnPorta] || chn.rowCommand.instr != 0)
chn.dwFlags.reset(CHN_KEYOFF | CHN_NOTEFADE);
chn.dwFlags = (chn.dwFlags & (CHN_CHANNELFLAGS | CHN_PINGPONGFLAG));
} else //if(!instrumentChanged || chn.rowCommand.instr != 0 || !IsCompatibleMode(TRK_FASTTRACKER2)) // SampleChange.xm?
{
chn.dwFlags.reset(CHN_KEYOFF | CHN_NOTEFADE);
// IT compatibility: Don't change bidi loop direction when no sample nor instrument is changed.
if((m_playBehaviour[kITPingPongNoReset] || !(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))) && pSmp == chn.pModSample && !instrumentChanged)
chn.dwFlags = (chn.dwFlags & (CHN_CHANNELFLAGS | CHN_PINGPONGFLAG));
else
chn.dwFlags = (chn.dwFlags & CHN_CHANNELFLAGS);
if(pIns)
{
// Copy envelope flags (we actually only need the "enabled" and "pitch" flag)
chn.VolEnv.flags = pIns->VolEnv.dwFlags;
chn.PanEnv.flags = pIns->PanEnv.dwFlags;
chn.PitchEnv.flags = pIns->PitchEnv.dwFlags;
// A cutoff frequency of 0 should not be reset just because the filter envelope is enabled.
// Test case: FilterEnvReset.it
if((pIns->PitchEnv.dwFlags & (ENV_ENABLED | ENV_FILTER)) == (ENV_ENABLED | ENV_FILTER) && !m_playBehaviour[kITFilterBehaviour])
{
if(!chn.nCutOff) chn.nCutOff = 0x7F;
}
if(pIns->IsCutoffEnabled()) chn.nCutOff = pIns->GetCutoff();
if(pIns->IsResonanceEnabled()) chn.nResonance = pIns->GetResonance();
}
}
if(pSmp == nullptr)
{
chn.pModSample = nullptr;
chn.nLength = 0;
return;
}
if(bPorta && chn.nLength == 0 && (m_playBehaviour[kFT2PortaNoNote] || m_playBehaviour[kITPortaNoNote]))
{
// IT/FT2 compatibility: If the note just stopped on the previous tick, prevent it from restarting.
// Test cases: PortaJustStoppedNote.xm, PortaJustStoppedNote.it
chn.increment.Set(0);
}
// IT compatibility: Note-off with instrument number + Old Effects retriggers envelopes.
// If the instrument changes, keep playing the previous sample, but load the new instrument's envelopes.
// Test case: ResetEnvNoteOffOldFx.it
if(chn.rowCommand.note == NOTE_KEYOFF && m_playBehaviour[kITInstrWithNoteOffOldEffects] && m_SongFlags[SONG_ITOLDEFFECTS] && sampleChanged)
{
if(chn.pModSample)
{
chn.dwFlags |= (chn.pModSample->uFlags & CHN_SAMPLEFLAGS);
}
chn.nInsVol = oldInsVol;
chn.nVolume = pSmp->nVolume;
if(pSmp->uFlags[CHN_PANNING]) chn.SetInstrumentPan(pSmp->nPan, *this);
return;
}
chn.pModSample = pSmp;
chn.nLength = pSmp->nLength;
chn.nLoopStart = pSmp->nLoopStart;
chn.nLoopEnd = pSmp->nLoopEnd;
// ProTracker "oneshot" loops (if loop start is 0, play the whole sample once and then repeat until loop end)
if(m_playBehaviour[kMODOneShotLoops] && chn.nLoopStart == 0) chn.nLoopEnd = pSmp->nLength;
chn.dwFlags |= (pSmp->uFlags & CHN_SAMPLEFLAGS);
// IT Compatibility: Autovibrato reset
if(m_playBehaviour[kITVibratoTremoloPanbrello])
{
chn.nAutoVibDepth = 0;
chn.nAutoVibPos = 0;
}
if(newTuning)
{
chn.nC5Speed = pSmp->nC5Speed;
chn.m_CalculateFreq = true;
chn.nFineTune = 0;
} else if(!bPorta || sampleChanged || !(GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM)))
{
// Don't reset finetune changed by "set finetune" command.
// Test case: finetune.xm, finetune.mod
// But *do* change the finetune if we switch to a different sample, to fix
// Miranda`s axe by Jamson (jam007.xm).
chn.nC5Speed = pSmp->nC5Speed;
chn.nFineTune = pSmp->nFineTune;
}
chn.nTranspose = UseFinetuneAndTranspose() ? pSmp->RelativeTone : 0;
// FT2 compatibility: Don't reset portamento target with new instrument numbers.
// Test case: Porta-Pickup.xm
// ProTracker does the same.
// Test case: PortaTarget.mod
if(!m_playBehaviour[kFT2PortaTargetNoReset] && GetType() != MOD_TYPE_MOD)
{
chn.nPortamentoDest = 0;
}
chn.m_PortamentoFineSteps = 0;
if(chn.dwFlags[CHN_SUSTAINLOOP])
{
chn.nLoopStart = pSmp->nSustainStart;
chn.nLoopEnd = pSmp->nSustainEnd;
if(chn.dwFlags[CHN_PINGPONGSUSTAIN]) chn.dwFlags.set(CHN_PINGPONGLOOP);
chn.dwFlags.set(CHN_LOOP);
}
if(chn.dwFlags[CHN_LOOP] && chn.nLoopEnd < chn.nLength) chn.nLength = chn.nLoopEnd;
// Fix sample position on instrument change. This is needed for IT "on the fly" sample change.
// XXX is this actually called? In ProcessEffects(), a note-on effect is emulated if there's an on the fly sample change!
if(chn.position.GetUInt() >= chn.nLength)
{
if((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)))
{
chn.position.Set(0);
}
}
}
void CSoundFile::NoteChange(ModChannel &chn, int note, bool bPorta, bool bResetEnv, bool bManual, CHANNELINDEX channelHint) const
{
if(note < NOTE_MIN)
return;
const int origNote = note;
const ModSample *pSmp = chn.pModSample;
const ModInstrument *pIns = chn.pModInstrument;
const bool newTuning = (GetType() == MOD_TYPE_MPT && pIns != nullptr && pIns->pTuning);
// save the note that's actually used, as it's necessary to properly calculate PPS and stuff
const int realnote = note;
if((pIns) && (note - NOTE_MIN < (int)std::size(pIns->Keyboard)))
{
uint32 n = pIns->Keyboard[note - NOTE_MIN];
if((n) && (n < MAX_SAMPLES))
{
pSmp = &Samples[n];
} else if(m_playBehaviour[kITEmptyNoteMapSlot] && !chn.HasMIDIOutput())
{
// Impulse Tracker ignores empty slots.
// We won't ignore them if a plugin is assigned to this slot, so that VSTis still work as intended.
// Test case: emptyslot.it, PortaInsNum.it, gxsmp.it, gxsmp2.it
return;
}
note = pIns->NoteMap[note - NOTE_MIN];
}
// Key Off
if(note > NOTE_MAX)
{
// Key Off (+ Invalid Note for XM - TODO is this correct?)
if(note == NOTE_KEYOFF || !(GetType() & (MOD_TYPE_IT|MOD_TYPE_MPT)))
{
KeyOff(chn);
// IT compatibility: Note-off + instrument releases sample sustain but does not release envelopes or fade the instrument
// Test case: noteoff3.it, ResetEnvNoteOffOldFx2.it
if(!bPorta && m_playBehaviour[kITInstrWithNoteOffOldEffects] && m_SongFlags[SONG_ITOLDEFFECTS] && chn.rowCommand.instr)
chn.dwFlags.reset(CHN_NOTEFADE | CHN_KEYOFF);
} else // Invalid Note -> Note Fade
{
if(/*note == NOTE_FADE && */ GetNumInstruments())
chn.dwFlags.set(CHN_NOTEFADE);
}
// Note Cut
if (note == NOTE_NOTECUT)
{
if(chn.dwFlags[CHN_ADLIB] && GetType() == MOD_TYPE_S3M)
{
// OPL voices are not cut but enter the release portion of their envelope
// In S3M we can still modify the volume after note-off, in legacy MPTM mode we can't
chn.dwFlags.set(CHN_KEYOFF);
} else
{
chn.dwFlags.set(CHN_NOTEFADE | CHN_FASTVOLRAMP);
// IT compatibility: Stopping sample playback by setting sample increment to 0 rather than volume
// Test case: NoteOffInstr.it
if ((!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))) || (m_nInstruments != 0 && !m_playBehaviour[kITInstrWithNoteOff])) chn.nVolume = 0;
if (m_playBehaviour[kITInstrWithNoteOff]) chn.increment.Set(0);
chn.nFadeOutVol = 0;
}
}
// IT compatibility tentative fix: Clear channel note memory (TRANCE_N.IT by A3F).
if(m_playBehaviour[kITClearOldNoteAfterCut])
{
chn.nNote = chn.nNewNote = NOTE_NONE;
}
return;
}
if(newTuning)
{
if(!bPorta || chn.nNote == NOTE_NONE)
chn.nPortamentoDest = 0;
else
{
chn.nPortamentoDest = pIns->pTuning->GetStepDistance(chn.nNote, chn.m_PortamentoFineSteps, static_cast<Tuning::NOTEINDEXTYPE>(note), 0);
//Here chn.nPortamentoDest means 'steps to slide'.
chn.m_PortamentoFineSteps = -chn.nPortamentoDest;
}
}
if(!bPorta && (GetType() & (MOD_TYPE_XM | MOD_TYPE_MED | MOD_TYPE_MT2)))
{
if(pSmp)
{
chn.nTranspose = pSmp->RelativeTone;
chn.nFineTune = pSmp->nFineTune;
}
}
// IT Compatibility: Update multisample instruments frequency even if instrument is not specified (fixes the guitars in spx-shuttledeparture.it)
// Test case: freqreset-noins.it
if(!bPorta && pSmp && m_playBehaviour[kITMultiSampleBehaviour])
chn.nC5Speed = pSmp->nC5Speed;
if(bPorta && !chn.IsSamplePlaying())
{
if(m_playBehaviour[kFT2PortaNoNote])
{
// FT2 Compatibility: Ignore notes with portamento if there was no note playing.
// Test case: 3xx-no-old-samp.xm
chn.nPeriod = 0;
return;
} else if(m_playBehaviour[kITPortaNoNote])
{
// IT Compatibility: Ignore portamento command if no note was playing (e.g. if a previous note has faded out).
// Test case: Fade-Porta.it
bPorta = false;
}
}
if(UseFinetuneAndTranspose())
{
note += chn.nTranspose;
// RealNote = PatternNote + RelativeTone; (0..118, 0 = C-0, 118 = A#9)
Limit(note, NOTE_MIN + 11, NOTE_MIN + 130); // 119 possible notes
} else
{
Limit(note, NOTE_MIN, NOTE_MAX);
}
if(m_playBehaviour[kITRealNoteMapping])
{
// need to memorize the original note for various effects (e.g. PPS)
chn.nNote = static_cast<ModCommand::NOTE>(Clamp(realnote, NOTE_MIN, NOTE_MAX));
} else
{
chn.nNote = static_cast<ModCommand::NOTE>(note);
}
chn.m_CalculateFreq = true;
chn.isPaused = false;
if ((!bPorta) || (GetType() & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT)))
chn.nNewIns = 0;
uint32 period = GetPeriodFromNote(note, chn.nFineTune, chn.nC5Speed);
chn.nPanbrelloOffset = 0;
// IT compatibility: Sample and instrument panning is only applied on note change, not instrument change
// Test case: PanReset.it
if(m_playBehaviour[kITPanningReset])
ApplyInstrumentPanning(chn, pIns, pSmp);
// IT compatibility: Pitch/Pan Separation can be overriden by panning commands, and shouldn't be affected by note-off commands
// Test case: PitchPanReset.it
if(m_playBehaviour[kITPitchPanSeparation] && pIns && pIns->nPPS)
{
if(!chn.nRestorePanOnNewNote)
chn.nRestorePanOnNewNote = static_cast<uint16>(chn.nPan + 1);
ProcessPitchPanSeparation(chn.nPan, origNote, *pIns);
}
if(bResetEnv && !bPorta)
{
chn.nVolSwing = chn.nPanSwing = 0;
chn.nResSwing = chn.nCutSwing = 0;
if(pIns)
{
// IT Compatiblity: NNA is reset on every note change, not every instrument change (fixes spx-farspacedance.it).
if(m_playBehaviour[kITNNAReset]) chn.nNNA = pIns->nNNA;
if(!pIns->VolEnv.dwFlags[ENV_CARRY]) chn.VolEnv.Reset();
if(!pIns->PanEnv.dwFlags[ENV_CARRY]) chn.PanEnv.Reset();
if(!pIns->PitchEnv.dwFlags[ENV_CARRY]) chn.PitchEnv.Reset();
// Volume Swing
if(pIns->nVolSwing)
{
chn.nVolSwing = static_cast<int16>(((mpt::random<int8>(AccessPRNG()) * pIns->nVolSwing) / 64 + 1) * (m_playBehaviour[kITSwingBehaviour] ? chn.nInsVol : ((chn.nVolume + 1) / 2)) / 199);
}
// Pan Swing
if(pIns->nPanSwing)
{
chn.nPanSwing = static_cast<int16>(((mpt::random<int8>(AccessPRNG()) * pIns->nPanSwing * 4) / 128));
if(!m_playBehaviour[kITSwingBehaviour] && chn.nRestorePanOnNewNote == 0)
{
chn.nRestorePanOnNewNote = static_cast<uint16>(chn.nPan + 1);
}
}
// Cutoff Swing
if(pIns->nCutSwing)
{
int32 d = ((int32)pIns->nCutSwing * (int32)(static_cast<int32>(mpt::random<int8>(AccessPRNG())) + 1)) / 128;
chn.nCutSwing = static_cast<int16>((d * chn.nCutOff + 1) / 128);
chn.nRestoreCutoffOnNewNote = chn.nCutOff + 1;
}
// Resonance Swing
if(pIns->nResSwing)
{
int32 d = ((int32)pIns->nResSwing * (int32)(static_cast<int32>(mpt::random<int8>(AccessPRNG())) + 1)) / 128;
chn.nResSwing = static_cast<int16>((d * chn.nResonance + 1) / 128);
chn.nRestoreResonanceOnNewNote = chn.nResonance + 1;
}
}
}
if(!pSmp) return;
if(period)
{
if((!bPorta) || (!chn.nPeriod)) chn.nPeriod = period;
if(!newTuning)
{
// FT2 compatibility: Don't reset portamento target with new notes.
// Test case: Porta-Pickup.xm
// ProTracker does the same.
// Test case: PortaTarget.mod
// IT compatibility: Portamento target is completely cleared with new notes.
// Test case: PortaReset.it
if(bPorta || !(m_playBehaviour[kFT2PortaTargetNoReset] || m_playBehaviour[kITClearPortaTarget] || GetType() == MOD_TYPE_MOD))
{
chn.nPortamentoDest = period;
chn.portaTargetReached = false;
}
}
if(!bPorta || (!chn.nLength && !(GetType() & MOD_TYPE_S3M)))
{
chn.pModSample = pSmp;
chn.nLength = pSmp->nLength;
chn.nLoopEnd = pSmp->nLength;
chn.nLoopStart = 0;
chn.position.Set(0);
if((m_SongFlags[SONG_PT_MODE] || m_playBehaviour[kST3OffsetWithoutInstrument]) && !chn.rowCommand.instr)
{
chn.position.SetInt(std::min(chn.prevNoteOffset, chn.nLength - SmpLength(1)));
} else
{
chn.prevNoteOffset = 0;
}
chn.dwFlags = (chn.dwFlags & CHN_CHANNELFLAGS) | (pSmp->uFlags & CHN_SAMPLEFLAGS);
chn.dwFlags.reset(CHN_PORTAMENTO);
if(chn.dwFlags[CHN_SUSTAINLOOP])
{
chn.nLoopStart = pSmp->nSustainStart;
chn.nLoopEnd = pSmp->nSustainEnd;
chn.dwFlags.set(CHN_PINGPONGLOOP, chn.dwFlags[CHN_PINGPONGSUSTAIN]);
chn.dwFlags.set(CHN_LOOP);
if (chn.nLength > chn.nLoopEnd) chn.nLength = chn.nLoopEnd;
} else if(chn.dwFlags[CHN_LOOP])
{
chn.nLoopStart = pSmp->nLoopStart;
chn.nLoopEnd = pSmp->nLoopEnd;
if (chn.nLength > chn.nLoopEnd) chn.nLength = chn.nLoopEnd;
}
// ProTracker "oneshot" loops (if loop start is 0, play the whole sample once and then repeat until loop end)
if(m_playBehaviour[kMODOneShotLoops] && chn.nLoopStart == 0) chn.nLoopEnd = chn.nLength = pSmp->nLength;
if(chn.dwFlags[CHN_REVERSE] && chn.nLength > 0)
{
chn.dwFlags.set(CHN_PINGPONGFLAG);
chn.position.SetInt(chn.nLength - 1);
}
// Handle "retrigger" waveform type
if(chn.nVibratoType < 4)
{
// IT Compatibilty: Slightly different waveform offsets (why does MPT have two different offsets here with IT old effects enabled and disabled?)
if(!m_playBehaviour[kITVibratoTremoloPanbrello] && (GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && !m_SongFlags[SONG_ITOLDEFFECTS])
chn.nVibratoPos = 0x10;
else if(GetType() == MOD_TYPE_MTM)
chn.nVibratoPos = 0x20;
else if(!(GetType() & (MOD_TYPE_DIGI | MOD_TYPE_DBM)))
chn.nVibratoPos = 0;
}
// IT Compatibility: No "retrigger" waveform here
if(!m_playBehaviour[kITVibratoTremoloPanbrello] && chn.nTremoloType < 4)
{
chn.nTremoloPos = 0;
}
}
if(chn.position.GetUInt() >= chn.nLength) chn.position.SetInt(chn.nLoopStart);
} else
{
bPorta = false;
}
if (!bPorta
|| (!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_DBM)))
|| (chn.dwFlags[CHN_NOTEFADE] && !chn.nFadeOutVol)
|| (m_SongFlags[SONG_ITCOMPATGXX] && chn.rowCommand.instr != 0))
{
if((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_DBM)) && chn.dwFlags[CHN_NOTEFADE] && !chn.nFadeOutVol)
{
chn.ResetEnvelopes();
// IT Compatibility: Autovibrato reset
if(!m_playBehaviour[kITVibratoTremoloPanbrello])
{
chn.nAutoVibDepth = 0;
chn.nAutoVibPos = 0;
}
chn.dwFlags.reset(CHN_NOTEFADE);
chn.nFadeOutVol = 65536;
}
if ((!bPorta) || (!m_SongFlags[SONG_ITCOMPATGXX]) || (chn.rowCommand.instr))
{
if ((!(GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2))) || (chn.rowCommand.instr))
{
chn.dwFlags.reset(CHN_NOTEFADE);
chn.nFadeOutVol = 65536;
}
}
}
// IT compatibility: Don't reset key-off flag on porta notes unless Compat Gxx is enabled.
// Test case: Off-Porta.it, Off-Porta-CompatGxx.it, Off-Porta.xm
if(m_playBehaviour[kITFT2DontResetNoteOffOnPorta] && bPorta && (!m_SongFlags[SONG_ITCOMPATGXX] || chn.rowCommand.instr == 0))
chn.dwFlags.reset(CHN_EXTRALOUD);
else
chn.dwFlags.reset(CHN_EXTRALOUD | CHN_KEYOFF);
// Enable Ramping
if(!bPorta)
{
chn.nLeftVU = chn.nRightVU = 0xFF;
chn.dwFlags.reset(CHN_FILTER);
chn.dwFlags.set(CHN_FASTVOLRAMP);
// IT compatibility 15. Retrigger is reset in RetrigNote (Tremor doesn't store anything here, so we just don't reset this as well)
if(!m_playBehaviour[kITRetrigger] && !m_playBehaviour[kITTremor])
{
// FT2 compatibility: Retrigger is reset in RetrigNote, tremor in ProcessEffects
if(!m_playBehaviour[kFT2Retrigger] && !m_playBehaviour[kFT2Tremor])
{
chn.nRetrigCount = 0;
chn.nTremorCount = 0;
}
}
if(bResetEnv)
{
chn.nAutoVibDepth = 0;
chn.nAutoVibPos = 0;
}
chn.rightVol = chn.leftVol = 0;
bool useFilter = !m_SongFlags[SONG_MPTFILTERMODE];
// Setup Initial Filter for this note
if(pIns)
{
if(pIns->IsResonanceEnabled())
{
chn.nResonance = pIns->GetResonance();
useFilter = true;
}
if(pIns->IsCutoffEnabled())
{
chn.nCutOff = pIns->GetCutoff();
useFilter = true;
}
if(useFilter && (pIns->filterMode != FilterMode::Unchanged))
{
chn.nFilterMode = pIns->filterMode;
}
} else
{
chn.nVolSwing = chn.nPanSwing = 0;
chn.nCutSwing = chn.nResSwing = 0;
}
if((chn.nCutOff < 0x7F || m_playBehaviour[kITFilterBehaviour]) && useFilter)
{
int cutoff = SetupChannelFilter(chn, true);
if(cutoff >= 0 && chn.dwFlags[CHN_ADLIB] && m_opl && channelHint != CHANNELINDEX_INVALID)
m_opl->Volume(channelHint, chn.nCutOff / 2u, true);
}
if(chn.dwFlags[CHN_ADLIB] && m_opl && channelHint != CHANNELINDEX_INVALID)
{
// Test case: AdlibZeroVolumeNote.s3m
if(m_playBehaviour[kOPLNoteOffOnNoteChange])
m_opl->NoteOff(channelHint);
else if(m_playBehaviour[kOPLNoteStopWith0Hz])
m_opl->Frequency(channelHint, 0, true, false);
}
}
// Special case for MPT
if (bManual) chn.dwFlags.reset(CHN_MUTE);
if((chn.dwFlags[CHN_MUTE] && (m_MixerSettings.MixerFlags & SNDMIX_MUTECHNMODE))
|| (chn.pModSample != nullptr && chn.pModSample->uFlags[CHN_MUTE] && !bManual)
|| (chn.pModInstrument != nullptr && chn.pModInstrument->dwFlags[INS_MUTE] && !bManual))
{
if (!bManual) chn.nPeriod = 0;
}
// Reset the Amiga resampler for this channel
if(!bPorta)
{
chn.paulaState.Reset();
}
}
// Apply sample or instrument panning
void CSoundFile::ApplyInstrumentPanning(ModChannel &chn, const ModInstrument *instr, const ModSample *smp) const
{
int32 newPan = int32_min;
// Default instrument panning
if(instr != nullptr && instr->dwFlags[INS_SETPANNING])
newPan = instr->nPan;
// Default sample panning
if(smp != nullptr && smp->uFlags[CHN_PANNING])
newPan = smp->nPan;
if(newPan != int32_min)
{
chn.SetInstrumentPan(newPan, *this);
// IT compatibility: Sample and instrument panning overrides channel surround status.
// Test case: SmpInsPanSurround.it
if(m_playBehaviour[kPanOverride] && !m_SongFlags[SONG_SURROUNDPAN])
{
chn.dwFlags.reset(CHN_SURROUND);
}
}
}
CHANNELINDEX CSoundFile::GetNNAChannel(CHANNELINDEX nChn) const
{
// Check for empty channel
for(CHANNELINDEX i = m_nChannels; i < MAX_CHANNELS; i++)
{
const ModChannel &c = m_PlayState.Chn[i];
// No sample and no plugin playing
if(!c.nLength && !c.HasMIDIOutput())
return i;
// Plugin channel with already released note
if(!c.nLength && c.dwFlags[CHN_KEYOFF | CHN_NOTEFADE])
return i;
// Stopped OPL channel
if(c.dwFlags[CHN_ADLIB] && (!m_opl || !m_opl->IsActive(i)))
return i;
}
uint32 vol = 0x800000;
if(nChn < MAX_CHANNELS)
{
const ModChannel &srcChn = m_PlayState.Chn[nChn];
if(!srcChn.nFadeOutVol && srcChn.nLength)
return CHANNELINDEX_INVALID;
vol = (srcChn.nRealVolume << 9) | srcChn.nVolume;
}
// All channels are used: check for lowest volume
CHANNELINDEX result = CHANNELINDEX_INVALID;
uint32 envpos = 0;
for(CHANNELINDEX i = m_nChannels; i < MAX_CHANNELS; i++)
{
const ModChannel &c = m_PlayState.Chn[i];
if(c.nLength && !c.nFadeOutVol)
return i;
// Use a combination of real volume [14 bit] (which includes volume envelopes, but also potentially global volume) and note volume [9 bit].
// Rationale: We need volume envelopes in case e.g. all NNA channels are playing at full volume but are looping on a 0-volume envelope node.
// But if global volume is not applied to master and the global volume temporarily drops to 0, we would kill arbitrary channels. Hence, add the note volume as well.
uint32 v = (c.nRealVolume << 9) | c.nVolume;
if(c.dwFlags[CHN_LOOP])
v /= 2;
if((v < vol) || ((v == vol) && (c.VolEnv.nEnvPosition > envpos)))
{
envpos = c.VolEnv.nEnvPosition;
vol = v;
result = i;
}
}
return result;
}
CHANNELINDEX CSoundFile::CheckNNA(CHANNELINDEX nChn, uint32 instr, int note, bool forceCut)
{
ModChannel &srcChn = m_PlayState.Chn[nChn];
const ModInstrument *pIns = nullptr;
if(!ModCommand::IsNote(static_cast<ModCommand::NOTE>(note)))
return CHANNELINDEX_INVALID;
// Always NNA cut - using
if((!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_MT2)) || !m_nInstruments || forceCut) && !srcChn.HasMIDIOutput())
{
if(!srcChn.nLength || srcChn.dwFlags[CHN_MUTE] || !(srcChn.rightVol | srcChn.leftVol))
return CHANNELINDEX_INVALID;
if(srcChn.dwFlags[CHN_ADLIB] && m_opl)
{
m_opl->NoteCut(nChn, false);
return CHANNELINDEX_INVALID;
}
const CHANNELINDEX nnaChn = GetNNAChannel(nChn);
if(nnaChn == CHANNELINDEX_INVALID)
return CHANNELINDEX_INVALID;
ModChannel &chn = m_PlayState.Chn[nnaChn];
// Copy Channel
chn = srcChn;
chn.dwFlags.reset(CHN_VIBRATO | CHN_TREMOLO | CHN_MUTE | CHN_PORTAMENTO);
chn.nPanbrelloOffset = 0;
chn.nMasterChn = nChn + 1;
chn.nCommand = CMD_NONE;
chn.rowCommand.Clear();
// Cut the note
chn.nFadeOutVol = 0;
chn.dwFlags.set(CHN_NOTEFADE | CHN_FASTVOLRAMP);
// Stop this channel
srcChn.nLength = 0;
srcChn.position.Set(0);
srcChn.nROfs = srcChn.nLOfs = 0;
srcChn.rightVol = srcChn.leftVol = 0;
return nnaChn;
}
if(instr > GetNumInstruments())
instr = 0;
const ModSample *pSample = srcChn.pModSample;
// If no instrument is given, assume previous instrument to still be valid.
// Test case: DNA-NoInstr.it
pIns = instr > 0 ? Instruments[instr] : srcChn.pModInstrument;
auto dnaNote = note;
if(pIns != nullptr)
{
auto smp = pIns->Keyboard[note - NOTE_MIN];
// IT compatibility: DCT = note uses pattern notes for comparison
// Note: This is not applied in case kITRealNoteMapping is not set to keep playback of legacy modules simple (chn.nNote is translated note in that case)
// Test case: dct_smp_note_test.it
if(!m_playBehaviour[kITDCTBehaviour] || !m_playBehaviour[kITRealNoteMapping])
dnaNote = pIns->NoteMap[note - NOTE_MIN];
if(smp > 0 && smp < MAX_SAMPLES)
{
pSample = &Samples[smp];
} else if(m_playBehaviour[kITEmptyNoteMapSlot] && !pIns->HasValidMIDIChannel())
{
// Impulse Tracker ignores empty slots.
// We won't ignore them if a plugin is assigned to this slot, so that VSTis still work as intended.
// Test case: emptyslot.it, PortaInsNum.it, gxsmp.it, gxsmp2.it
return CHANNELINDEX_INVALID;
}
}
if(srcChn.dwFlags[CHN_MUTE])
return CHANNELINDEX_INVALID;
for(CHANNELINDEX i = nChn; i < MAX_CHANNELS; i++)
{
// Only apply to background channels, or the same pattern channel
if(i < m_nChannels && i != nChn)
continue;
ModChannel &chn = m_PlayState.Chn[i];
bool applyDNAtoPlug = false;
if((chn.nMasterChn == nChn + 1 || i == nChn) && chn.pModInstrument != nullptr)
{
bool applyDNA = false;
// Duplicate Check Type
switch(chn.pModInstrument->nDCT)
{
case DuplicateCheckType::None:
break;
// Note
case DuplicateCheckType::Note:
if(dnaNote != NOTE_NONE && chn.nNote == dnaNote && pIns == chn.pModInstrument)
applyDNA = true;
if(pIns && pIns->nMixPlug)
applyDNAtoPlug = true;
break;
// Sample
case DuplicateCheckType::Sample:
// IT compatibility: DCT = sample only applies to same instrument
// Test case: dct_smp_note_test.it
if(pSample != nullptr && pSample == chn.pModSample && (pIns == chn.pModInstrument || !m_playBehaviour[kITDCTBehaviour]))
applyDNA = true;
break;
// Instrument
case DuplicateCheckType::Instrument:
if(pIns == chn.pModInstrument)
applyDNA = true;
if(pIns && pIns->nMixPlug)
applyDNAtoPlug = true;
break;
// Plugin
case DuplicateCheckType::Plugin:
if(pIns && (pIns->nMixPlug) && (pIns->nMixPlug == chn.pModInstrument->nMixPlug))
{
applyDNAtoPlug = true;
applyDNA = true;
}
break;
}
// Duplicate Note Action
if(applyDNA)
{
#ifndef NO_PLUGINS
if(applyDNAtoPlug && chn.nNote != NOTE_NONE)
{
switch(chn.pModInstrument->nDNA)
{
case DuplicateNoteAction::NoteCut:
case DuplicateNoteAction::NoteOff:
case DuplicateNoteAction::NoteFade:
// Switch off duplicated note played on this plugin
if(const auto oldNote = chn.GetPluginNote(m_playBehaviour[kITRealNoteMapping]); oldNote != NOTE_NONE)
{
SendMIDINote(i, oldNote + NOTE_MAX_SPECIAL, 0);
chn.nArpeggioLastNote = NOTE_NONE;
chn.nNote = NOTE_NONE;
}
break;
}
}
#endif // NO_PLUGINS
switch(chn.pModInstrument->nDNA)
{
// Cut
case DuplicateNoteAction::NoteCut:
KeyOff(chn);
chn.nVolume = 0;
if(chn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->NoteCut(i);
break;
// Note Off
case DuplicateNoteAction::NoteOff:
KeyOff(chn);
if(chn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->NoteOff(i);
break;
// Note Fade
case DuplicateNoteAction::NoteFade:
chn.dwFlags.set(CHN_NOTEFADE);
if(chn.dwFlags[CHN_ADLIB] && m_opl && !m_playBehaviour[kOPLwithNNA])
m_opl->NoteOff(i);
break;
}
if(!chn.nVolume)
{
chn.nFadeOutVol = 0;
chn.dwFlags.set(CHN_NOTEFADE | CHN_FASTVOLRAMP);
}
}
}
}
// Do we need to apply New/Duplicate Note Action to a VSTi?
bool applyNNAtoPlug = false;
#ifndef NO_PLUGINS
IMixPlugin *pPlugin = nullptr;
if(srcChn.HasMIDIOutput() && ModCommand::IsNote(srcChn.nNote)) // instro sends to a midi chan
{
PLUGINDEX plugin = GetBestPlugin(m_PlayState, nChn, PrioritiseInstrument, RespectMutes);
if(plugin > 0 && plugin <= MAX_MIXPLUGINS)
{
pPlugin = m_MixPlugins[plugin - 1].pMixPlugin;
if(pPlugin)
{
// apply NNA to this plugin iff it is currently playing a note on this tracker channel
// (and if it is playing a note, we know that would be the last note played on this chan).
const auto oldNote = srcChn.GetPluginNote(m_playBehaviour[kITRealNoteMapping]);
applyNNAtoPlug = (oldNote != NOTE_NONE) && pPlugin->IsNotePlaying(oldNote, nChn);
}
}
}
#endif // NO_PLUGINS
// New Note Action
if(!srcChn.IsSamplePlaying() && !applyNNAtoPlug)
return CHANNELINDEX_INVALID;
#ifndef NO_PLUGINS
if(applyNNAtoPlug && pPlugin)
{
switch(srcChn.nNNA)
{
case NewNoteAction::NoteOff:
case NewNoteAction::NoteCut:
case NewNoteAction::NoteFade:
// Switch off note played on this plugin, on this tracker channel and midi channel
SendMIDINote(nChn, NOTE_KEYOFF, 0);
srcChn.nArpeggioLastNote = NOTE_NONE;
break;
case NewNoteAction::Continue:
break;
}
}
#endif // NO_PLUGINS
CHANNELINDEX nnaChn = GetNNAChannel(nChn);
if(nnaChn == CHANNELINDEX_INVALID)
return CHANNELINDEX_INVALID;
ModChannel &chn = m_PlayState.Chn[nnaChn];
if(chn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->NoteCut(nnaChn);
// Copy Channel
chn = srcChn;
chn.dwFlags.reset(CHN_VIBRATO | CHN_TREMOLO | CHN_PORTAMENTO);
chn.nPanbrelloOffset = 0;
chn.nMasterChn = nChn < GetNumChannels() ? nChn + 1 : 0;
chn.nCommand = CMD_NONE;
// Key Off the note
switch(srcChn.nNNA)
{
case NewNoteAction::NoteOff:
KeyOff(chn);
if(chn.dwFlags[CHN_ADLIB] && m_opl)
{
m_opl->NoteOff(nChn);
if(m_playBehaviour[kOPLwithNNA])
m_opl->MoveChannel(nChn, nnaChn);
}
break;
case NewNoteAction::NoteCut:
chn.nFadeOutVol = 0;
chn.dwFlags.set(CHN_NOTEFADE);
if(chn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->NoteCut(nChn);
break;
case NewNoteAction::NoteFade:
chn.dwFlags.set(CHN_NOTEFADE);
if(chn.dwFlags[CHN_ADLIB] && m_opl)
{
if(m_playBehaviour[kOPLwithNNA])
m_opl->MoveChannel(nChn, nnaChn);
else
m_opl->NoteOff(nChn);
}
break;
case NewNoteAction::Continue:
if(chn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->MoveChannel(nChn, nnaChn);
break;
}
if(!chn.nVolume)
{
chn.nFadeOutVol = 0;
chn.dwFlags.set(CHN_NOTEFADE | CHN_FASTVOLRAMP);
}
// Stop this channel
srcChn.nLength = 0;
srcChn.position.Set(0);
srcChn.nROfs = srcChn.nLOfs = 0;
return nnaChn;
}
bool CSoundFile::ProcessEffects()
{
m_PlayState.m_breakRow = ROWINDEX_INVALID; // Is changed if a break to row command is encountered
m_PlayState.m_patLoopRow = ROWINDEX_INVALID; // Is changed if a pattern loop jump-back is executed
m_PlayState.m_posJump = ORDERINDEX_INVALID;
for(CHANNELINDEX nChn = 0; nChn < GetNumChannels(); nChn++)
{
ModChannel &chn = m_PlayState.Chn[nChn];
const uint32 tickCount = m_PlayState.m_nTickCount % (m_PlayState.m_nMusicSpeed + m_PlayState.m_nFrameDelay);
uint32 instr = chn.rowCommand.instr;
ModCommand::VOLCMD volcmd = chn.rowCommand.volcmd;
uint32 vol = chn.rowCommand.vol;
ModCommand::COMMAND cmd = chn.rowCommand.command;
uint32 param = chn.rowCommand.param;
bool bPorta = chn.rowCommand.IsPortamento();
uint32 nStartTick = 0;
chn.isFirstTick = m_SongFlags[SONG_FIRSTTICK];
// Process parameter control note.
if(chn.rowCommand.note == NOTE_PC)
{
#ifndef NO_PLUGINS
const PLUGINDEX plug = chn.rowCommand.instr;
const PlugParamIndex plugparam = chn.rowCommand.GetValueVolCol();
const PlugParamValue value = chn.rowCommand.GetValueEffectCol() / PlugParamValue(ModCommand::maxColumnValue);
if(plug > 0 && plug <= MAX_MIXPLUGINS && m_MixPlugins[plug - 1].pMixPlugin)
m_MixPlugins[plug-1].pMixPlugin->SetParameter(plugparam, value);
#endif // NO_PLUGINS
}
// Process continuous parameter control note.
// Row data is cleared after first tick so on following
// ticks using channels m_nPlugParamValueStep to identify
// the need for parameter control. The condition cmd == 0
// is to make sure that m_nPlugParamValueStep != 0 because
// of NOTE_PCS, not because of macro.
if(chn.rowCommand.note == NOTE_PCS || (cmd == CMD_NONE && chn.m_plugParamValueStep != 0))
{
#ifndef NO_PLUGINS
const bool isFirstTick = m_SongFlags[SONG_FIRSTTICK];
if(isFirstTick)
chn.m_RowPlug = chn.rowCommand.instr;
const PLUGINDEX plugin = chn.m_RowPlug;
const bool hasValidPlug = (plugin > 0 && plugin <= MAX_MIXPLUGINS && m_MixPlugins[plugin - 1].pMixPlugin);
if(hasValidPlug)
{
if(isFirstTick)
chn.m_RowPlugParam = ModCommand::GetValueVolCol(chn.rowCommand.volcmd, chn.rowCommand.vol);
const PlugParamIndex plugparam = chn.m_RowPlugParam;
if(isFirstTick)
{
PlugParamValue targetvalue = ModCommand::GetValueEffectCol(chn.rowCommand.command, chn.rowCommand.param) / PlugParamValue(ModCommand::maxColumnValue);
chn.m_plugParamTargetValue = targetvalue;
chn.m_plugParamValueStep = (targetvalue - m_MixPlugins[plugin - 1].pMixPlugin->GetParameter(plugparam)) / PlugParamValue(m_PlayState.TicksOnRow());
}
if(m_PlayState.m_nTickCount + 1 == m_PlayState.TicksOnRow())
{ // On last tick, set parameter exactly to target value.
m_MixPlugins[plugin - 1].pMixPlugin->SetParameter(plugparam, chn.m_plugParamTargetValue);
}
else
m_MixPlugins[plugin - 1].pMixPlugin->ModifyParameter(plugparam, chn.m_plugParamValueStep);
}
#endif // NO_PLUGINS
}
// Apart from changing parameters, parameter control notes are intended to be 'invisible'.
// To achieve this, clearing the note data so that rest of the process sees the row as empty row.
if(ModCommand::IsPcNote(chn.rowCommand.note))
{
chn.ClearRowCmd();
instr = 0;
volcmd = VOLCMD_NONE;
vol = 0;
cmd = CMD_NONE;
param = 0;
bPorta = false;
}
// Process Invert Loop (MOD Effect, called every row if it's active)
if(!m_SongFlags[SONG_FIRSTTICK])
{
InvertLoop(m_PlayState.Chn[nChn]);
} else
{
if(instr) m_PlayState.Chn[nChn].nEFxOffset = 0;
}
// Process special effects (note delay, pattern delay, pattern loop)
if (cmd == CMD_DELAYCUT)
{
//:xy --> note delay until tick x, note cut at tick x+y
nStartTick = (param & 0xF0) >> 4;
const uint32 cutAtTick = nStartTick + (param & 0x0F);
NoteCut(nChn, cutAtTick, m_playBehaviour[kITSCxStopsSample]);
} else if ((cmd == CMD_MODCMDEX) || (cmd == CMD_S3MCMDEX))
{
if ((!param) && (GetType() & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT)))
param = chn.nOldCmdEx;
else
chn.nOldCmdEx = static_cast<ModCommand::PARAM>(param);
// Note Delay ?
if ((param & 0xF0) == 0xD0)
{
nStartTick = param & 0x0F;
if(nStartTick == 0)
{
//IT compatibility 22. SD0 == SD1
if(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))
nStartTick = 1;
//ST3 ignores notes with SD0 completely
else if(GetType() == MOD_TYPE_S3M)
continue;
} else if(nStartTick >= (m_PlayState.m_nMusicSpeed + m_PlayState.m_nFrameDelay) && m_playBehaviour[kITOutOfRangeDelay])
{
// IT compatibility 08. Handling of out-of-range delay command.
// Additional test case: tickdelay.it
if(instr)
{
chn.nNewIns = static_cast<ModCommand::INSTR>(instr);
}
continue;
}
} else if(m_SongFlags[SONG_FIRSTTICK])
{
// Pattern Loop ?
if((param & 0xF0) == 0xE0)
{
// Pattern Delay
// In Scream Tracker 3 / Impulse Tracker, only the first delay command on this row is considered.
// Test cases: PatternDelays.it, PatternDelays.s3m, PatternDelays.xm
// XXX In Scream Tracker 3, the "left" channels are evaluated before the "right" channels, which is not emulated here!
if(!(GetType() & (MOD_TYPE_S3M | MOD_TYPE_IT | MOD_TYPE_MPT)) || !m_PlayState.m_nPatternDelay)
{
if(!(GetType() & (MOD_TYPE_S3M)) || (param & 0x0F) != 0)
{
// While Impulse Tracker *does* count S60 as a valid row delay (and thus ignores any other row delay commands on the right),
// Scream Tracker 3 simply ignores such commands.
m_PlayState.m_nPatternDelay = 1 + (param & 0x0F);
}
}
}
}
}
if(GetType() == MOD_TYPE_MTM && cmd == CMD_MODCMDEX && (param & 0xF0) == 0xD0)
{
// Apparently, retrigger and note delay have the same behaviour in MultiTracker:
// They both restart the note at tick x, and if there is a note on the same row,
// this note is started on the first tick.
nStartTick = 0;
param = 0x90 | (param & 0x0F);
}
if(nStartTick != 0 && chn.rowCommand.note == NOTE_KEYOFF && chn.rowCommand.volcmd == VOLCMD_PANNING && m_playBehaviour[kFT2PanWithDelayedNoteOff])
{
// FT2 compatibility: If there's a delayed note off, panning commands are ignored. WTF!
// Test case: PanOff.xm
chn.rowCommand.volcmd = VOLCMD_NONE;
}
bool triggerNote = (m_PlayState.m_nTickCount == nStartTick); // Can be delayed by a note delay effect
if(m_playBehaviour[kFT2OutOfRangeDelay] && nStartTick >= m_PlayState.m_nMusicSpeed)
{
// FT2 compatibility: Note delays greater than the song speed should be ignored.
// However, EEx pattern delay is *not* considered at all.
// Test case: DelayCombination.xm, PortaDelay.xm
triggerNote = false;
} else if(m_playBehaviour[kRowDelayWithNoteDelay] && nStartTick > 0 && tickCount == nStartTick)
{
// IT compatibility: Delayed notes (using SDx) that are on the same row as a Row Delay effect are retriggered.
// ProTracker / Scream Tracker 3 / FastTracker 2 do the same.
// Test case: PatternDelay-NoteDelay.it, PatternDelay-NoteDelay.xm, PatternDelaysRetrig.mod
triggerNote = true;
}
// IT compatibility: Tick-0 vs non-tick-0 effect distinction is always based on tick delay.
// Test case: SlideDelay.it
if(m_playBehaviour[kITFirstTickHandling])
{
chn.isFirstTick = tickCount == nStartTick;
}
chn.triggerNote = triggerNote;
// FT2 compatibility: Note + portamento + note delay = no portamento
// Test case: PortaDelay.xm
if(m_playBehaviour[kFT2PortaDelay] && nStartTick != 0)
{
bPorta = false;
}
if(m_SongFlags[SONG_PT_MODE] && instr && !m_PlayState.m_nTickCount)
{
// Instrument number resets the stacked ProTracker offset.
// Test case: ptoffset.mod
chn.prevNoteOffset = 0;
// ProTracker compatibility: Sample properties are always loaded on the first tick, even when there is a note delay.
// Test case: InstrDelay.mod
if(!triggerNote && chn.IsSamplePlaying())
{
chn.nNewIns = static_cast<ModCommand::INSTR>(instr);
if(instr <= GetNumSamples())
{
chn.nVolume = Samples[instr].nVolume;
chn.nFineTune = Samples[instr].nFineTune;
}
}
}
// Handles note/instrument/volume changes
if(triggerNote)
{
ModCommand::NOTE note = chn.rowCommand.note;
if(instr) chn.nNewIns = static_cast<ModCommand::INSTR>(instr);
if(ModCommand::IsNote(note) && m_playBehaviour[kFT2Transpose])
{
// Notes that exceed FT2's limit are completely ignored.
// Test case: NoteLimit.xm
int transpose = chn.nTranspose;
if(instr && !bPorta)
{
// Refresh transpose
// Test case: NoteLimit2.xm
const SAMPLEINDEX sample = GetSampleIndex(note, instr);
if(sample > 0)
transpose = GetSample(sample).RelativeTone;
}
const int computedNote = note + transpose;
if((computedNote < NOTE_MIN + 11 || computedNote > NOTE_MIN + 130))
{
note = NOTE_NONE;
}
} else if((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_J2B)) && GetNumInstruments() != 0 && ModCommand::IsNoteOrEmpty(static_cast<ModCommand::NOTE>(note)))
{
// IT compatibility: Invalid instrument numbers do nothing, but they are remembered for upcoming notes and do not trigger a note in that case.
// Test case: InstrumentNumberChange.it
INSTRUMENTINDEX instrToCheck = static_cast<INSTRUMENTINDEX>((instr != 0) ? instr : chn.nOldIns);
if(instrToCheck != 0 && (instrToCheck > GetNumInstruments() || Instruments[instrToCheck] == nullptr))
{
note = NOTE_NONE;
instr = 0;
}
}
// XM: FT2 ignores a note next to a K00 effect, and a fade-out seems to be done when no volume envelope is present (not exactly the Kxx behaviour)
if(cmd == CMD_KEYOFF && param == 0 && m_playBehaviour[kFT2KeyOff])
{
note = NOTE_NONE;
instr = 0;
}
bool retrigEnv = note == NOTE_NONE && instr != 0;
// Apparently, any note number in a pattern causes instruments to recall their original volume settings - no matter if there's a Note Off next to it or whatever.
// Test cases: keyoff+instr.xm, delay.xm
bool reloadSampleSettings = (m_playBehaviour[kFT2ReloadSampleSettings] && instr != 0);
// ProTracker Compatibility: If a sample was stopped before, lone instrument numbers can retrigger it
// Test case: PTSwapEmpty.mod, PTInstrVolume.mod, SampleSwap.s3m
bool keepInstr = (GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))
|| m_playBehaviour[kST3SampleSwap]
|| (m_playBehaviour[kMODSampleSwap] && !chn.IsSamplePlaying() && (chn.pModSample == nullptr || !chn.pModSample->HasSampleData()));
// Now it's time for some FT2 crap...
if (GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2))
{
// XM: Key-Off + Sample == Note Cut (BUT: Only if no instr number or volume effect is present!)
// Test case: NoteOffVolume.xm
if(note == NOTE_KEYOFF
&& ((!instr && volcmd != VOLCMD_VOLUME && cmd != CMD_VOLUME) || !m_playBehaviour[kFT2KeyOff])
&& (chn.pModInstrument == nullptr || !chn.pModInstrument->VolEnv.dwFlags[ENV_ENABLED]))
{
chn.dwFlags.set(CHN_FASTVOLRAMP);
chn.nVolume = 0;
note = NOTE_NONE;
instr = 0;
retrigEnv = false;
// FT2 Compatbility: Start fading the note for notes with no delay. Only relevant when a volume command is encountered after the note-off.
// Test case: NoteOffFadeNoEnv.xm
if(m_SongFlags[SONG_FIRSTTICK] && m_playBehaviour[kFT2NoteOffFlags])
chn.dwFlags.set(CHN_NOTEFADE);
} else if(m_playBehaviour[kFT2RetrigWithNoteDelay] && !m_SongFlags[SONG_FIRSTTICK])
{
// FT2 Compatibility: Some special hacks for rogue note delays... (EDx with x > 0)
// Apparently anything that is next to a note delay behaves totally unpredictable in FT2. Swedish tracker logic. :)
retrigEnv = true;
// Portamento + Note Delay = No Portamento
// Test case: porta-delay.xm
bPorta = false;
if(note == NOTE_NONE)
{
// If there's a note delay but no real note, retrig the last note.
// Test case: delay2.xm, delay3.xm
note = static_cast<ModCommand::NOTE>(chn.nNote - chn.nTranspose);
} else if(note >= NOTE_MIN_SPECIAL)
{
// Gah! Even Note Off + Note Delay will cause envelopes to *retrigger*! How stupid is that?
// ... Well, and that is actually all it does if there's an envelope. No fade out, no nothing. *sigh*
// Test case: OffDelay.xm
note = NOTE_NONE;
keepInstr = false;
reloadSampleSettings = true;
} else if(instr || !m_playBehaviour[kFT2NoteDelayWithoutInstr])
{
// Normal note (only if there is an instrument, test case: DelayVolume.xm)
keepInstr = true;
reloadSampleSettings = true;
}
}
}
if((retrigEnv && !m_playBehaviour[kFT2ReloadSampleSettings]) || reloadSampleSettings)
{
const ModSample *oldSample = nullptr;
// Reset default volume when retriggering envelopes
if(GetNumInstruments())
{
oldSample = chn.pModSample;
} else if (instr <= GetNumSamples())
{
// Case: Only samples are used; no instruments.
oldSample = &Samples[instr];
}
if(oldSample != nullptr)
{
if(!oldSample->uFlags[SMP_NODEFAULTVOLUME] && (GetType() != MOD_TYPE_S3M || oldSample->HasSampleData()))
chn.nVolume = oldSample->nVolume;
if(reloadSampleSettings)
{
// Also reload panning
chn.SetInstrumentPan(oldSample->nPan, *this);
}
}
}
// FT2 compatibility: Instrument number disables tremor effect
// Test case: TremorInstr.xm, TremoRecover.xm
if(m_playBehaviour[kFT2Tremor] && instr != 0)
{
chn.nTremorCount = 0x20;
}
// IT compatibility: Envelope retriggering with instrument number based on Old Effects and Compatible Gxx flags:
// OldFX CompatGxx Env Behaviour
// ----- --------- -------------
// off off never reset
// on off reset on instrument without portamento
// off on reset on instrument with portamento
// on on always reset
// Test case: ins-xx.it, ins-ox.it, ins-oc.it, ins-xc.it, ResetEnvNoteOffOldFx.it, ResetEnvNoteOffOldFx2.it, noteoff3.it
if(GetNumInstruments() && m_playBehaviour[kITInstrWithNoteOffOldEffects]
&& instr && !ModCommand::IsNote(note))
{
if((bPorta && m_SongFlags[SONG_ITCOMPATGXX])
|| (!bPorta && m_SongFlags[SONG_ITOLDEFFECTS]))
{
chn.ResetEnvelopes();
chn.dwFlags.set(CHN_FASTVOLRAMP);
chn.nFadeOutVol = 65536;
}
}
if(retrigEnv) //Case: instrument with no note data.
{
//IT compatibility: Instrument with no note.
if(m_playBehaviour[kITInstrWithoutNote] || GetType() == MOD_TYPE_PLM)
{
// IT compatibility: Completely retrigger note after sample end to also reset portamento.
// Test case: PortaResetAfterRetrigger.it
bool triggerAfterSmpEnd = m_playBehaviour[kITMultiSampleInstrumentNumber] && !chn.IsSamplePlaying();
if(GetNumInstruments())
{
// Instrument mode
if(instr <= GetNumInstruments() && (chn.pModInstrument != Instruments[instr] || triggerAfterSmpEnd))
note = chn.nNote;
} else
{
// Sample mode
if(instr < MAX_SAMPLES && (chn.pModSample != &Samples[instr] || triggerAfterSmpEnd))
note = chn.nNote;
}
}
if(GetNumInstruments() && (GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2 | MOD_TYPE_MED)))
{
chn.ResetEnvelopes();
chn.dwFlags.set(CHN_FASTVOLRAMP);
chn.dwFlags.reset(CHN_NOTEFADE);
chn.nAutoVibDepth = 0;
chn.nAutoVibPos = 0;
chn.nFadeOutVol = 65536;
// FT2 Compatbility: Reset key-off status with instrument number
// Test case: NoteOffInstrChange.xm
if(m_playBehaviour[kFT2NoteOffFlags])
chn.dwFlags.reset(CHN_KEYOFF);
}
if (!keepInstr) instr = 0;
}
// Note Cut/Off/Fade => ignore instrument
if (note >= NOTE_MIN_SPECIAL)
{
// IT compatibility: Default volume of sample is recalled if instrument number is next to a note-off.
// Test case: NoteOffInstr.it, noteoff2.it
if(m_playBehaviour[kITInstrWithNoteOff] && instr)
{
const SAMPLEINDEX smp = GetSampleIndex(chn.nLastNote, instr);
if(smp > 0 && !Samples[smp].uFlags[SMP_NODEFAULTVOLUME])
chn.nVolume = Samples[smp].nVolume;
}
// IT compatibility: Note-off with instrument number + Old Effects retriggers envelopes.
// Test case: ResetEnvNoteOffOldFx.it
if(!m_playBehaviour[kITInstrWithNoteOffOldEffects] || !m_SongFlags[SONG_ITOLDEFFECTS])
instr = 0;
}
if(ModCommand::IsNote(note))
{
chn.nNewNote = chn.nLastNote = note;
// New Note Action ?
if(!bPorta)
{
CheckNNA(nChn, instr, note, false);
}
chn.RestorePanAndFilter();
}
// Instrument Change ?
if(instr)
{
const ModSample *oldSample = chn.pModSample;
//const ModInstrument *oldInstrument = chn.pModInstrument;
InstrumentChange(chn, instr, bPorta, true);
if(chn.pModSample != nullptr && chn.pModSample->uFlags[CHN_ADLIB] && m_opl)
{
m_opl->Patch(nChn, chn.pModSample->adlib);
}
// IT compatibility: Keep new instrument number for next instrument-less note even if sample playback is stopped
// Test case: StoppedInstrSwap.it
if(GetType() == MOD_TYPE_MOD)
{
// Test case: PortaSwapPT.mod
if(!bPorta || !m_playBehaviour[kMODSampleSwap]) chn.nNewIns = 0;
} else
{
if(!m_playBehaviour[kITInstrWithNoteOff] || ModCommand::IsNote(note)) chn.nNewIns = 0;
}
if(m_playBehaviour[kITPortamentoSwapResetsPos])
{
// Test cases: PortaInsNum.it, PortaSample.it
if(ModCommand::IsNote(note) && oldSample != chn.pModSample)
{
//const bool newInstrument = oldInstrument != chn.pModInstrument && chn.pModInstrument->Keyboard[chn.nNewNote - NOTE_MIN] != 0;
chn.position.Set(0);
}
} else if((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && oldSample != chn.pModSample && ModCommand::IsNote(note))
{
// Special IT case: portamento+note causes sample change -> ignore portamento
bPorta = false;
} else if(m_playBehaviour[kST3SampleSwap] && oldSample != chn.pModSample && (bPorta || !ModCommand::IsNote(note)) && chn.position.GetUInt() > chn.nLength)
{
// ST3 with SoundBlaster does sample swapping and continues playing the new sample where the old sample was stopped.
// If the new sample is shorter than that, it is stopped, even if it could be looped.
// This also applies to portamento between different samples.
// Test case: SampleSwap.s3m
chn.nLength = 0;
} else if(m_playBehaviour[kMODSampleSwap] && !chn.IsSamplePlaying())
{
// If channel was paused and is resurrected by a lone instrument number, reset the sample position.
// Test case: PTSwapEmpty.mod
chn.position.Set(0);
}
}
// New Note ?
if (note != NOTE_NONE)
{
const bool instrChange = (!instr) && (chn.nNewIns) && ModCommand::IsNote(note);
if(instrChange)
{
InstrumentChange(chn, chn.nNewIns, bPorta, chn.pModSample == nullptr && chn.pModInstrument == nullptr, !(GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2)));
chn.nNewIns = 0;
}
if(chn.pModSample != nullptr && chn.pModSample->uFlags[CHN_ADLIB] && m_opl && (instrChange || !m_opl->IsActive(nChn)))
{
m_opl->Patch(nChn, chn.pModSample->adlib);
}
NoteChange(chn, note, bPorta, !(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2)), false, nChn);
HandleDigiSamplePlayDirection(m_PlayState, nChn);
if ((bPorta) && (GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2)) && (instr))
{
chn.dwFlags.set(CHN_FASTVOLRAMP);
chn.ResetEnvelopes();
chn.nAutoVibDepth = 0;
chn.nAutoVibPos = 0;
}
if(chn.dwFlags[CHN_ADLIB] && m_opl
&& ((note == NOTE_NOTECUT || note == NOTE_KEYOFF) || (note == NOTE_FADE && !m_playBehaviour[kOPLFlexibleNoteOff])))
{
if(m_playBehaviour[kOPLNoteStopWith0Hz])
m_opl->Frequency(nChn, 0, true, false);
m_opl->NoteOff(nChn);
}
}
// Tick-0 only volume commands
if (volcmd == VOLCMD_VOLUME)
{
if (vol > 64) vol = 64;
chn.nVolume = vol << 2;
chn.dwFlags.set(CHN_FASTVOLRAMP);
} else
if (volcmd == VOLCMD_PANNING)
{
Panning(chn, vol, Pan6bit);
}
#ifndef NO_PLUGINS
if (m_nInstruments) ProcessMidiOut(nChn);
#endif // NO_PLUGINS
}
if(m_playBehaviour[kST3NoMutedChannels] && ChnSettings[nChn].dwFlags[CHN_MUTE]) // not even effects are processed on muted S3M channels
continue;
// Volume Column Effect (except volume & panning)
/* A few notes, paraphrased from ITTECH.TXT by Storlek (creator of schismtracker):
Ex/Fx/Gx are shared with Exx/Fxx/Gxx; Ex/Fx are 4x the 'normal' slide value
Gx is linked with Ex/Fx if Compat Gxx is off, just like Gxx is with Exx/Fxx
Gx values: 1, 4, 8, 16, 32, 64, 96, 128, 255
Ax/Bx/Cx/Dx values are used directly (i.e. D9 == D09), and are NOT shared with Dxx
(value is stored into nOldVolParam and used by A0/B0/C0/D0)
Hx uses the same value as Hxx and Uxx, and affects the *depth*
so... hxx = (hx | (oldhxx & 0xf0)) ???
TODO is this done correctly?
*/
bool doVolumeColumn = m_PlayState.m_nTickCount >= nStartTick;
// FT2 compatibility: If there's a note delay, volume column effects are NOT executed
// on the first tick and, if there's an instrument number, on the delayed tick.
// Test case: VolColDelay.xm, PortaDelay.xm
if(m_playBehaviour[kFT2VolColDelay] && nStartTick != 0)
{
doVolumeColumn = m_PlayState.m_nTickCount != 0 && (m_PlayState.m_nTickCount != nStartTick || (chn.rowCommand.instr == 0 && volcmd != VOLCMD_TONEPORTAMENTO));
}
if(volcmd > VOLCMD_PANNING && doVolumeColumn)
{
if(volcmd == VOLCMD_TONEPORTAMENTO)
{
const auto [porta, clearEffectCommand] = GetVolCmdTonePorta(chn.rowCommand, nStartTick);
if(clearEffectCommand)
cmd = CMD_NONE;
TonePortamento(chn, porta);
} else
{
// FT2 Compatibility: FT2 ignores some volume commands with parameter = 0.
if(m_playBehaviour[kFT2VolColMemory] && vol == 0)
{
switch(volcmd)
{
case VOLCMD_VOLUME:
case VOLCMD_PANNING:
case VOLCMD_VIBRATODEPTH:
break;
case VOLCMD_PANSLIDELEFT:
// FT2 Compatibility: Pan slide left with zero parameter causes panning to be set to full left on every non-row tick.
// Test case: PanSlideZero.xm
if(!m_SongFlags[SONG_FIRSTTICK])
{
chn.nPan = 0;
}
[[fallthrough]];
default:
// no memory here.
volcmd = VOLCMD_NONE;
}
} else if(!m_playBehaviour[kITVolColMemory])
{
// IT Compatibility: Effects in the volume column don't have an unified memory.
// Test case: VolColMemory.it
if(vol) chn.nOldVolParam = static_cast<ModCommand::PARAM>(vol); else vol = chn.nOldVolParam;
}
switch(volcmd)
{
case VOLCMD_VOLSLIDEUP:
case VOLCMD_VOLSLIDEDOWN:
// IT Compatibility: Volume column volume slides have their own memory
// Test case: VolColMemory.it
if(vol == 0 && m_playBehaviour[kITVolColMemory])
{
vol = chn.nOldVolParam;
if(vol == 0)
break;
} else
{
chn.nOldVolParam = static_cast<ModCommand::PARAM>(vol);
}
VolumeSlide(chn, static_cast<ModCommand::PARAM>(volcmd == VOLCMD_VOLSLIDEUP ? (vol << 4) : vol));
break;
case VOLCMD_FINEVOLUP:
// IT Compatibility: Fine volume slides in the volume column are only executed on the first tick, not on multiples of the first tick in case of pattern delay
// Test case: FineVolColSlide.it
if(m_PlayState.m_nTickCount == nStartTick || !m_playBehaviour[kITVolColMemory])
{
// IT Compatibility: Volume column volume slides have their own memory
// Test case: VolColMemory.it
FineVolumeUp(chn, static_cast<ModCommand::PARAM>(vol), m_playBehaviour[kITVolColMemory]);
}
break;
case VOLCMD_FINEVOLDOWN:
// IT Compatibility: Fine volume slides in the volume column are only executed on the first tick, not on multiples of the first tick in case of pattern delay
// Test case: FineVolColSlide.it
if(m_PlayState.m_nTickCount == nStartTick || !m_playBehaviour[kITVolColMemory])
{
// IT Compatibility: Volume column volume slides have their own memory
// Test case: VolColMemory.it
FineVolumeDown(chn, static_cast<ModCommand::PARAM>(vol), m_playBehaviour[kITVolColMemory]);
}
break;
case VOLCMD_VIBRATOSPEED:
// FT2 does not automatically enable vibrato with the "set vibrato speed" command
if(m_playBehaviour[kFT2VolColVibrato])
chn.nVibratoSpeed = vol & 0x0F;
else
Vibrato(chn, vol << 4);
break;
case VOLCMD_VIBRATODEPTH:
Vibrato(chn, vol);
break;
case VOLCMD_PANSLIDELEFT:
PanningSlide(chn, static_cast<ModCommand::PARAM>(vol), !m_playBehaviour[kFT2VolColMemory]);
break;
case VOLCMD_PANSLIDERIGHT:
PanningSlide(chn, static_cast<ModCommand::PARAM>(vol << 4), !m_playBehaviour[kFT2VolColMemory]);
break;
case VOLCMD_PORTAUP:
// IT compatibility (one of the first testcases - link effect memory)
PortamentoUp(nChn, static_cast<ModCommand::PARAM>(vol << 2), m_playBehaviour[kITVolColFinePortamento]);
break;
case VOLCMD_PORTADOWN:
// IT compatibility (one of the first testcases - link effect memory)
PortamentoDown(nChn, static_cast<ModCommand::PARAM>(vol << 2), m_playBehaviour[kITVolColFinePortamento]);
break;
case VOLCMD_OFFSET:
if(triggerNote && chn.pModSample && vol <= std::size(chn.pModSample->cues))
{
SmpLength offset;
if(vol == 0)
offset = chn.oldOffset;
else
offset = chn.oldOffset = chn.pModSample->cues[vol - 1];
SampleOffset(chn, offset);
}
break;
case VOLCMD_PLAYCONTROL:
if(vol <= 1)
chn.isPaused = (vol == 0);
break;
}
}
}
// Effects
if(cmd != CMD_NONE) switch (cmd)
{
// Set Volume
case CMD_VOLUME:
if(m_SongFlags[SONG_FIRSTTICK])
{
chn.nVolume = (param < 64) ? param * 4 : 256;
chn.dwFlags.set(CHN_FASTVOLRAMP);
}
break;
// Portamento Up
case CMD_PORTAMENTOUP:
if ((!param) && (GetType() & MOD_TYPE_MOD)) break;
PortamentoUp(nChn, static_cast<ModCommand::PARAM>(param));
break;
// Portamento Down
case CMD_PORTAMENTODOWN:
if ((!param) && (GetType() & MOD_TYPE_MOD)) break;
PortamentoDown(nChn, static_cast<ModCommand::PARAM>(param));
break;
// Volume Slide
case CMD_VOLUMESLIDE:
if (param || (GetType() != MOD_TYPE_MOD)) VolumeSlide(chn, static_cast<ModCommand::PARAM>(param));
break;
// Tone-Portamento
case CMD_TONEPORTAMENTO:
TonePortamento(chn, static_cast<uint16>(param));
break;
// Tone-Portamento + Volume Slide
case CMD_TONEPORTAVOL:
if ((param) || (GetType() != MOD_TYPE_MOD)) VolumeSlide(chn, static_cast<ModCommand::PARAM>(param));
TonePortamento(chn, 0);
break;
// Vibrato
case CMD_VIBRATO:
Vibrato(chn, param);
break;
// Vibrato + Volume Slide
case CMD_VIBRATOVOL:
if ((param) || (GetType() != MOD_TYPE_MOD)) VolumeSlide(chn, static_cast<ModCommand::PARAM>(param));
Vibrato(chn, 0);
break;
// Set Speed
case CMD_SPEED:
if(m_SongFlags[SONG_FIRSTTICK])
SetSpeed(m_PlayState, param);
break;
// Set Tempo
case CMD_TEMPO:
if(m_playBehaviour[kMODVBlankTiming])
{
// ProTracker MODs with VBlank timing: All Fxx parameters set the tick count.
if(m_SongFlags[SONG_FIRSTTICK] && param != 0) SetSpeed(m_PlayState, param);
break;
}
{
param = CalculateXParam(m_PlayState.m_nPattern, m_PlayState.m_nRow, nChn);
if (GetType() & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT))
{
if (param) chn.nOldTempo = static_cast<ModCommand::PARAM>(param); else param = chn.nOldTempo;
}
TEMPO t(param, 0);
LimitMax(t, GetModSpecifications().GetTempoMax());
SetTempo(t);
}
break;
// Set Offset
case CMD_OFFSET:
if(triggerNote)
{
// FT2 compatibility: Portamento + Offset = Ignore offset
// Test case: porta-offset.xm
if(bPorta && GetType() == MOD_TYPE_XM)
break;
ProcessSampleOffset(chn, nChn, m_PlayState);
}
break;
// Disorder Tracker 2 percentage offset
case CMD_OFFSETPERCENTAGE:
if(triggerNote)
{
SampleOffset(chn, Util::muldiv_unsigned(chn.nLength, param, 256));
}
break;
// Arpeggio
case CMD_ARPEGGIO:
// IT compatibility 01. Don't ignore Arpeggio if no note is playing (also valid for ST3)
if(m_PlayState.m_nTickCount) break;
if((!chn.nPeriod || !chn.nNote)
&& (chn.pModInstrument == nullptr || !chn.pModInstrument->HasValidMIDIChannel()) // Plugin arpeggio
&& !m_playBehaviour[kITArpeggio] && (GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))) break;
if (!param && (GetType() & (MOD_TYPE_XM | MOD_TYPE_MOD))) break; // Only important when editing MOD/XM files (000 effects are removed when loading files where this means "no effect")
chn.nCommand = CMD_ARPEGGIO;
if (param) chn.nArpeggio = static_cast<ModCommand::PARAM>(param);
break;
// Retrig
case CMD_RETRIG:
if (GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2))
{
if (!(param & 0xF0)) param |= chn.nRetrigParam & 0xF0;
if (!(param & 0x0F)) param |= chn.nRetrigParam & 0x0F;
param |= 0x100; // increment retrig count on first row
}
// IT compatibility 15. Retrigger
if(m_playBehaviour[kITRetrigger])
{
if (param) chn.nRetrigParam = static_cast<uint8>(param & 0xFF);
RetrigNote(nChn, chn.nRetrigParam, (volcmd == VOLCMD_OFFSET) ? vol + 1 : 0);
} else
{
// XM Retrig
if (param) chn.nRetrigParam = static_cast<uint8>(param & 0xFF); else param = chn.nRetrigParam;
RetrigNote(nChn, param, (volcmd == VOLCMD_OFFSET) ? vol + 1 : 0);
}
break;
// Tremor
case CMD_TREMOR:
if(!m_SongFlags[SONG_FIRSTTICK])
{
break;
}
// IT compatibility 12. / 13. Tremor (using modified DUMB's Tremor logic here because of old effects - http://dumb.sf.net/)
if(m_playBehaviour[kITTremor])
{
if(param && !m_SongFlags[SONG_ITOLDEFFECTS])
{
// Old effects have different length interpretation (+1 for both on and off)
if(param & 0xF0)
param -= 0x10;
if(param & 0x0F)
param -= 0x01;
chn.nTremorParam = static_cast<ModCommand::PARAM>(param);
}
chn.nTremorCount |= 0x80; // set on/off flag
} else if(m_playBehaviour[kFT2Tremor])
{
// XM Tremor. Logic is being processed in sndmix.cpp
chn.nTremorCount |= 0x80; // set on/off flag
}
chn.nCommand = CMD_TREMOR;
if(param)
chn.nTremorParam = static_cast<ModCommand::PARAM>(param);
break;
// Set Global Volume
case CMD_GLOBALVOLUME:
// IT compatibility: Only apply global volume on first tick (and multiples)
// Test case: GlobalVolFirstTick.it
if(!m_SongFlags[SONG_FIRSTTICK])
break;
// ST3 applies global volume on tick 1 and does other weird things, but we won't emulate this for now.
// if(((GetType() & MOD_TYPE_S3M) && m_nTickCount != 1)
// || (!(GetType() & MOD_TYPE_S3M) && !m_SongFlags[SONG_FIRSTTICK]))
// {
// break;
// }
// FT2 compatibility: On channels that are "left" of the global volume command, the new global volume is not applied
// until the second tick of the row. Since we apply global volume on the mix buffer rather than note volumes, this
// cannot be fixed for now.
// Test case: GlobalVolume.xm
// if(IsCompatibleMode(TRK_FASTTRACKER2) && m_SongFlags[SONG_FIRSTTICK] && m_nMusicSpeed > 1)
// {
// break;
// }
if (!(GetType() & GLOBALVOL_7BIT_FORMATS)) param *= 2;
// IT compatibility 16. ST3 and IT ignore out-of-range values.
// Test case: globalvol-invalid.it
if(param <= 128)
{
m_PlayState.m_nGlobalVolume = param * 2;
} else if(!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_S3M)))
{
m_PlayState.m_nGlobalVolume = 256;
}
break;
// Global Volume Slide
case CMD_GLOBALVOLSLIDE:
//IT compatibility 16. Saving last global volume slide param per channel (FT2/IT)
if(m_playBehaviour[kPerChannelGlobalVolSlide])
GlobalVolSlide(static_cast<ModCommand::PARAM>(param), chn.nOldGlobalVolSlide);
else
GlobalVolSlide(static_cast<ModCommand::PARAM>(param), m_PlayState.Chn[0].nOldGlobalVolSlide);
break;
// Set 8-bit Panning
case CMD_PANNING8:
if(m_SongFlags[SONG_FIRSTTICK])
{
Panning(chn, param, Pan8bit);
}
break;
// Panning Slide
case CMD_PANNINGSLIDE:
PanningSlide(chn, static_cast<ModCommand::PARAM>(param));
break;
// Tremolo
case CMD_TREMOLO:
Tremolo(chn, param);
break;
// Fine Vibrato
case CMD_FINEVIBRATO:
FineVibrato(chn, param);
break;
// MOD/XM Exx Extended Commands
case CMD_MODCMDEX:
ExtendedMODCommands(nChn, static_cast<ModCommand::PARAM>(param));
break;
// S3M/IT Sxx Extended Commands
case CMD_S3MCMDEX:
ExtendedS3MCommands(nChn, static_cast<ModCommand::PARAM>(param));
break;
// Key Off
case CMD_KEYOFF:
// This is how Key Off is supposed to sound... (in FT2 at least)
if(m_playBehaviour[kFT2KeyOff])
{
if (m_PlayState.m_nTickCount == param)
{
// XM: Key-Off + Sample == Note Cut
if(chn.pModInstrument == nullptr || !chn.pModInstrument->VolEnv.dwFlags[ENV_ENABLED])
{
if(param == 0 && (chn.rowCommand.instr || chn.rowCommand.volcmd != VOLCMD_NONE)) // FT2 is weird....
{
chn.dwFlags.set(CHN_NOTEFADE);
}
else
{
chn.dwFlags.set(CHN_FASTVOLRAMP);
chn.nVolume = 0;
}
}
KeyOff(chn);
}
}
// This is how it's NOT supposed to sound...
else
{
if(m_SongFlags[SONG_FIRSTTICK])
KeyOff(chn);
}
break;
// Extra-fine porta up/down
case CMD_XFINEPORTAUPDOWN:
switch(param & 0xF0)
{
case 0x10: ExtraFinePortamentoUp(chn, param & 0x0F); break;
case 0x20: ExtraFinePortamentoDown(chn, param & 0x0F); break;
// ModPlug XM Extensions (ignore in compatible mode)
case 0x50:
case 0x60:
case 0x70:
case 0x90:
case 0xA0:
if(!m_playBehaviour[kFT2RestrictXCommand]) ExtendedS3MCommands(nChn, static_cast<ModCommand::PARAM>(param));
break;
}
break;
case CMD_FINETUNE:
case CMD_FINETUNE_SMOOTH:
if(m_SongFlags[SONG_FIRSTTICK] || cmd == CMD_FINETUNE_SMOOTH)
{
SetFinetune(nChn, m_PlayState, cmd == CMD_FINETUNE_SMOOTH);
#ifndef NO_PLUGINS
if(IMixPlugin *plugin = GetChannelInstrumentPlugin(m_PlayState.Chn[nChn]); plugin != nullptr)
plugin->MidiPitchBendRaw(chn.GetMIDIPitchBend(), nChn);
#endif // NO_PLUGINS
}
break;
// Set Channel Global Volume
case CMD_CHANNELVOLUME:
if(!m_SongFlags[SONG_FIRSTTICK]) break;
if (param <= 64)
{
chn.nGlobalVol = param;
chn.dwFlags.set(CHN_FASTVOLRAMP);
}
break;
// Channel volume slide
case CMD_CHANNELVOLSLIDE:
ChannelVolSlide(chn, static_cast<ModCommand::PARAM>(param));
break;
// Panbrello (IT)
case CMD_PANBRELLO:
Panbrello(chn, param);
break;
// Set Envelope Position
case CMD_SETENVPOSITION:
if(m_SongFlags[SONG_FIRSTTICK])
{
chn.VolEnv.nEnvPosition = param;
// FT2 compatibility: FT2 only sets the position of the panning envelope if the volume envelope's sustain flag is set
// Test case: SetEnvPos.xm
if(!m_playBehaviour[kFT2SetPanEnvPos] || chn.VolEnv.flags[ENV_SUSTAIN])
{
chn.PanEnv.nEnvPosition = param;
chn.PitchEnv.nEnvPosition = param;
}
}
break;
// Position Jump
case CMD_POSITIONJUMP:
PositionJump(m_PlayState, nChn);
break;
// Pattern Break
case CMD_PATTERNBREAK:
if(ROWINDEX row = PatternBreak(m_PlayState, nChn, static_cast<ModCommand::PARAM>(param)); row != ROWINDEX_INVALID)
{
m_PlayState.m_breakRow = row;
if(m_SongFlags[SONG_PATTERNLOOP])
{
//If song is set to loop and a pattern break occurs we should stay on the same pattern.
//Use nPosJump to force playback to "jump to this pattern" rather than move to next, as by default.
m_PlayState.m_posJump = m_PlayState.m_nCurrentOrder;
}
}
break;
// IMF / PTM Note Slides
case CMD_NOTESLIDEUP:
case CMD_NOTESLIDEDOWN:
case CMD_NOTESLIDEUPRETRIG:
case CMD_NOTESLIDEDOWNRETRIG:
// Note that this command seems to be a bit buggy in Polytracker... Luckily, no tune seems to seriously use this
// (Vic uses it e.g. in Spaceman or Perfect Reason to slide effect samples, noone will notice the difference :)
NoteSlide(chn, param, cmd == CMD_NOTESLIDEUP || cmd == CMD_NOTESLIDEUPRETRIG, cmd == CMD_NOTESLIDEUPRETRIG || cmd == CMD_NOTESLIDEDOWNRETRIG);
break;
// PTM Reverse sample + offset (executed on every tick)
case CMD_REVERSEOFFSET:
ReverseSampleOffset(chn, static_cast<ModCommand::PARAM>(param));
break;
#ifndef NO_PLUGINS
// DBM: Toggle DSP Echo
case CMD_DBMECHO:
if(m_PlayState.m_nTickCount == 0)
{
uint32 echoType = (param >> 4), enable = (param & 0x0F);
if(echoType > 2 || enable > 1)
{
break;
}
CHANNELINDEX firstChn = nChn, lastChn = nChn;
if(echoType == 1)
{
firstChn = 0;
lastChn = m_nChannels - 1;
}
for(CHANNELINDEX c = firstChn; c <= lastChn; c++)
{
ChnSettings[c].dwFlags.set(CHN_NOFX, enable == 1);
m_PlayState.Chn[c].dwFlags.set(CHN_NOFX, enable == 1);
}
}
break;
#endif // NO_PLUGINS
// Digi Booster sample reverse
case CMD_DIGIREVERSESAMPLE:
DigiBoosterSampleReverse(chn, static_cast<ModCommand::PARAM>(param));
break;
}
if(m_playBehaviour[kST3EffectMemory] && param != 0)
{
UpdateS3MEffectMemory(chn, static_cast<ModCommand::PARAM>(param));
}
if(chn.rowCommand.instr)
{
// Not necessarily consistent with actually playing instrument for IT compatibility
chn.nOldIns = chn.rowCommand.instr;
}
} // for(...) end
// Navigation Effects
if(m_SongFlags[SONG_FIRSTTICK])
{
if(HandleNextRow(m_PlayState, Order(), true))
m_SongFlags.set(SONG_BREAKTOROW);
}
return true;
}
bool CSoundFile::HandleNextRow(PlayState &state, const ModSequence &order, bool honorPatternLoop) const
{
const bool doPatternLoop = (state.m_patLoopRow != ROWINDEX_INVALID);
const bool doBreakRow = (state.m_breakRow != ROWINDEX_INVALID);
const bool doPosJump = (state.m_posJump != ORDERINDEX_INVALID);
bool breakToRow = false;
// Pattern Break / Position Jump only if no loop running
// Exception: FastTracker 2 in all cases, Impulse Tracker in case of position jump
// Test case for FT2 exception: PatLoop-Jumps.xm, PatLoop-Various.xm
// Test case for IT: exception: LoopBreak.it, sbx-priority.it
if((doBreakRow || doPosJump)
&& (!doPatternLoop
|| m_playBehaviour[kFT2PatternLoopWithJumps]
|| (m_playBehaviour[kITPatternLoopWithJumps] && doPosJump)
|| (m_playBehaviour[kITPatternLoopWithJumpsOld] && doPosJump)))
{
if(!doPosJump)
state.m_posJump = state.m_nCurrentOrder + 1;
if(!doBreakRow)
state.m_breakRow = 0;
breakToRow = true;
if(state.m_posJump >= order.size())
state.m_posJump = order.GetRestartPos();
// IT / FT2 compatibility: don't reset loop count on pattern break.
// Test case: gm-trippy01.it, PatLoop-Break.xm, PatLoop-Weird.xm, PatLoop-Break.mod
if(state.m_posJump != state.m_nCurrentOrder
&& !m_playBehaviour[kITPatternLoopBreak] && !m_playBehaviour[kFT2PatternLoopWithJumps] && GetType() != MOD_TYPE_MOD)
{
for(CHANNELINDEX i = 0; i < GetNumChannels(); i++)
{
state.Chn[i].nPatternLoopCount = 0;
}
}
state.m_nNextRow = state.m_breakRow;
if(!honorPatternLoop || !m_SongFlags[SONG_PATTERNLOOP])
state.m_nNextOrder = state.m_posJump;
} else if(doPatternLoop)
{
// Pattern Loop
state.m_nNextOrder = state.m_nCurrentOrder;
state.m_nNextRow = state.m_patLoopRow;
// FT2 skips the first row of the pattern loop if there's a pattern delay, ProTracker sometimes does it too (didn't quite figure it out yet).
// But IT and ST3 don't do this.
// Test cases: PatLoopWithDelay.it, PatLoopWithDelay.s3m
if(state.m_nPatternDelay
&& (GetType() != MOD_TYPE_IT || !m_playBehaviour[kITPatternLoopWithJumps])
&& GetType() != MOD_TYPE_S3M)
{
state.m_nNextRow++;
}
// IT Compatibility: If the restart row is past the end of the current pattern
// (e.g. when continued from a previous pattern without explicit SB0 effect), continue the next pattern.
// Test case: LoopStartAfterPatternEnd.it
if(state.m_patLoopRow >= Patterns[state.m_nPattern].GetNumRows())
{
state.m_nNextOrder++;
state.m_nNextRow = 0;
}
}
return breakToRow;
}
////////////////////////////////////////////////////////////
// Channels effects
// Update the effect memory of all S3M effects that use the last non-zero effect parameter as memory (Dxy, Exx, Fxx, Ixy, Jxy, Kxy, Lxy, Qxy, Rxy, Sxy)
// Test case: ParamMemory.s3m
void CSoundFile::UpdateS3MEffectMemory(ModChannel &chn, ModCommand::PARAM param) const
{
chn.nOldVolumeSlide = param; // Dxy / Kxy / Lxy
chn.nOldPortaUp = param; // Exx / Fxx
chn.nOldPortaDown = param; // Exx / Fxx
chn.nTremorParam = param; // Ixy
chn.nArpeggio = param; // Jxy
chn.nRetrigParam = param; // Qxy
chn.nTremoloDepth = (param & 0x0F) << 2; // Rxy
chn.nTremoloSpeed = (param >> 4) & 0x0F; // Rxy
chn.nOldCmdEx = param; // Sxy
}
// Calculate full parameter for effects that support parameter extension at the given pattern location.
// maxCommands sets the maximum number of XParam commands to look at for this effect
// extendedRows returns how many extended rows are used (i.e. a value of 0 means the command is not extended).
uint32 CSoundFile::CalculateXParam(PATTERNINDEX pat, ROWINDEX row, CHANNELINDEX chn, uint32 *extendedRows) const
{
if(extendedRows != nullptr)
*extendedRows = 0;
if(!Patterns.IsValidPat(pat))
{
#ifdef MPT_BUILD_FUZZER
// Ending up in this situation implies a logic error
std::abort();
#else
return 0;
#endif
}
ROWINDEX maxCommands = 4;
const ModCommand *m = Patterns[pat].GetpModCommand(row, chn);
const auto startCmd = m->command;
uint32 val = m->param;
switch(m->command)
{
case CMD_OFFSET:
// 24 bit command
maxCommands = 2;
break;
case CMD_TEMPO:
case CMD_PATTERNBREAK:
case CMD_POSITIONJUMP:
case CMD_FINETUNE:
case CMD_FINETUNE_SMOOTH:
// 16 bit command
maxCommands = 1;
break;
default:
return val;
}
const bool xmTempoFix = m->command == CMD_TEMPO && GetType() == MOD_TYPE_XM;
ROWINDEX numRows = std::min(Patterns[pat].GetNumRows() - row - 1, maxCommands);
uint32 extRows = 0;
while(numRows > 0)
{
m += Patterns[pat].GetNumChannels();
if(m->command != CMD_XPARAM)
break;
if(xmTempoFix && val < 256)
{
// With XM, 0x20 is the lowest tempo. Anything below changes ticks per row.
val -= 0x20;
}
val = (val << 8) | m->param;
numRows--;
extRows++;
}
// Always return a full-precision value for finetune
if((startCmd == CMD_FINETUNE || startCmd == CMD_FINETUNE_SMOOTH) && !extRows)
val <<= 8;
if(extendedRows != nullptr)
*extendedRows = extRows;
return val;
}
void CSoundFile::PositionJump(PlayState &state, CHANNELINDEX chn) const
{
state.m_nextPatStartRow = 0; // FT2 E60 bug
state.m_posJump = static_cast<ORDERINDEX>(CalculateXParam(state.m_nPattern, state.m_nRow, chn));
// see https://forum.openmpt.org/index.php?topic=2769.0 - FastTracker resets Dxx if Bxx is called _after_ Dxx
// Test case: PatternJump.mod
if((GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM)) && state.m_breakRow != ROWINDEX_INVALID)
{
state.m_breakRow = 0;
}
}
ROWINDEX CSoundFile::PatternBreak(PlayState &state, CHANNELINDEX chn, uint8 param) const
{
if(param >= 64 && (GetType() & MOD_TYPE_S3M))
{
// ST3 ignores invalid pattern breaks.
return ROWINDEX_INVALID;
}
state.m_nextPatStartRow = 0; // FT2 E60 bug
return static_cast<ROWINDEX>(CalculateXParam(state.m_nPattern, state.m_nRow, chn));
}
void CSoundFile::PortamentoUp(CHANNELINDEX nChn, ModCommand::PARAM param, const bool doFinePortamentoAsRegular)
{
ModChannel &chn = m_PlayState.Chn[nChn];
if(param)
{
// FT2 compatibility: Separate effect memory for all portamento commands
// Test case: Porta-LinkMem.xm
if(!m_playBehaviour[kFT2PortaUpDownMemory])
chn.nOldPortaDown = param;
chn.nOldPortaUp = param;
} else
{
param = chn.nOldPortaUp;
}
const bool doFineSlides = !doFinePortamentoAsRegular && !(GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM | MOD_TYPE_MT2 | MOD_TYPE_MED | MOD_TYPE_AMF0 | MOD_TYPE_DIGI | MOD_TYPE_STP | MOD_TYPE_DTM));
// Process MIDI pitch bend for instrument plugins
MidiPortamento(nChn, param, doFineSlides);
if(GetType() == MOD_TYPE_MPT && chn.pModInstrument && chn.pModInstrument->pTuning)
{
// Portamento for instruments with custom tuning
if(param >= 0xF0 && !doFinePortamentoAsRegular)
PortamentoFineMPT(chn, param - 0xF0);
else if(param >= 0xE0 && !doFinePortamentoAsRegular)
PortamentoExtraFineMPT(chn, param - 0xE0);
else
PortamentoMPT(chn, param);
return;
} else if(GetType() == MOD_TYPE_PLM)
{
// A normal portamento up or down makes a follow-up tone portamento go the same direction.
chn.nPortamentoDest = 1;
}
if (doFineSlides && param >= 0xE0)
{
if (param & 0x0F)
{
if ((param & 0xF0) == 0xF0)
{
FinePortamentoUp(chn, param & 0x0F);
return;
} else if ((param & 0xF0) == 0xE0 && GetType() != MOD_TYPE_DBM)
{
ExtraFinePortamentoUp(chn, param & 0x0F);
return;
}
}
if(GetType() != MOD_TYPE_DBM)
{
// DBM only has fine slides, no extra-fine slides.
return;
}
}
// Regular Slide
if(!chn.isFirstTick
|| (m_PlayState.m_nMusicSpeed == 1 && m_playBehaviour[kSlidesAtSpeed1])
|| (GetType() & (MOD_TYPE_669 | MOD_TYPE_OKT))
|| (GetType() == MOD_TYPE_MED && m_SongFlags[SONG_FASTVOLSLIDES]))
{
DoFreqSlide(chn, chn.nPeriod, param * 4);
}
}
void CSoundFile::PortamentoDown(CHANNELINDEX nChn, ModCommand::PARAM param, const bool doFinePortamentoAsRegular)
{
ModChannel &chn = m_PlayState.Chn[nChn];
if(param)
{
// FT2 compatibility: Separate effect memory for all portamento commands
// Test case: Porta-LinkMem.xm
if(!m_playBehaviour[kFT2PortaUpDownMemory])
chn.nOldPortaUp = param;
chn.nOldPortaDown = param;
} else
{
param = chn.nOldPortaDown;
}
const bool doFineSlides = !doFinePortamentoAsRegular && !(GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM | MOD_TYPE_MT2 | MOD_TYPE_MED | MOD_TYPE_AMF0 | MOD_TYPE_DIGI | MOD_TYPE_STP | MOD_TYPE_DTM));
// Process MIDI pitch bend for instrument plugins
MidiPortamento(nChn, -static_cast<int>(param), doFineSlides);
if(GetType() == MOD_TYPE_MPT && chn.pModInstrument && chn.pModInstrument->pTuning)
{
// Portamento for instruments with custom tuning
if(param >= 0xF0 && !doFinePortamentoAsRegular)
PortamentoFineMPT(chn, -static_cast<int>(param - 0xF0));
else if(param >= 0xE0 && !doFinePortamentoAsRegular)
PortamentoExtraFineMPT(chn, -static_cast<int>(param - 0xE0));
else
PortamentoMPT(chn, -static_cast<int>(param));
return;
} else if(GetType() == MOD_TYPE_PLM)
{
// A normal portamento up or down makes a follow-up tone portamento go the same direction.
chn.nPortamentoDest = 65535;
}
if(doFineSlides && param >= 0xE0)
{
if (param & 0x0F)
{
if ((param & 0xF0) == 0xF0)
{
FinePortamentoDown(chn, param & 0x0F);
return;
} else if ((param & 0xF0) == 0xE0 && GetType() != MOD_TYPE_DBM)
{
ExtraFinePortamentoDown(chn, param & 0x0F);
return;
}
}
if(GetType() != MOD_TYPE_DBM)
{
// DBM only has fine slides, no extra-fine slides.
return;
}
}
if(!chn.isFirstTick
|| (m_PlayState.m_nMusicSpeed == 1 && m_playBehaviour[kSlidesAtSpeed1])
|| (GetType() & (MOD_TYPE_669 | MOD_TYPE_OKT))
|| (GetType() == MOD_TYPE_MED && m_SongFlags[SONG_FASTVOLSLIDES]))
{
DoFreqSlide(chn, chn.nPeriod, param * -4);
}
}
// Send portamento commands to plugins
void CSoundFile::MidiPortamento(CHANNELINDEX nChn, int param, bool doFineSlides)
{
int actualParam = std::abs(param);
int pitchBend = 0;
// Old MIDI Pitch Bends:
// - Applied on every tick
// - No fine pitch slides (they are interpreted as normal slides)
// New MIDI Pitch Bends:
// - Behaviour identical to sample pitch bends if the instrument's PWD parameter corresponds to the actual VSTi setting.
if(doFineSlides && actualParam >= 0xE0 && !m_playBehaviour[kOldMIDIPitchBends])
{
if(m_PlayState.Chn[nChn].isFirstTick)
{
// Extra fine slide...
pitchBend = (actualParam & 0x0F) * mpt::signum(param);
if(actualParam >= 0xF0)
{
// ... or just a fine slide!
pitchBend *= 4;
}
}
} else if(!m_PlayState.Chn[nChn].isFirstTick || m_playBehaviour[kOldMIDIPitchBends])
{
// Regular slide
pitchBend = param * 4;
}
if(pitchBend)
{
#ifndef NO_PLUGINS
IMixPlugin *plugin = GetChannelInstrumentPlugin(m_PlayState.Chn[nChn]);
if(plugin != nullptr)
{
int8 pwd = 13; // Early OpenMPT legacy... Actually it's not *exactly* 13, but close enough...
if(m_PlayState.Chn[nChn].pModInstrument != nullptr)
{
pwd = m_PlayState.Chn[nChn].pModInstrument->midiPWD;
}
plugin->MidiPitchBend(pitchBend, pwd, nChn);
}
#endif // NO_PLUGINS
}
}
void CSoundFile::FinePortamentoUp(ModChannel &chn, ModCommand::PARAM param) const
{
MPT_ASSERT(!chn.HasCustomTuning());
if(GetType() == MOD_TYPE_XM)
{
// FT2 compatibility: E1x / E2x / X1x / X2x memory is not linked
// Test case: Porta-LinkMem.xm
if(param) chn.nOldFinePortaUpDown = (chn.nOldFinePortaUpDown & 0x0F) | (param << 4); else param = (chn.nOldFinePortaUpDown >> 4);
} else if(GetType() == MOD_TYPE_MT2)
{
if(param) chn.nOldFinePortaUpDown = param; else param = chn.nOldFinePortaUpDown;
}
if(chn.isFirstTick && chn.nPeriod && param)
DoFreqSlide(chn, chn.nPeriod, param * 4);
}
void CSoundFile::FinePortamentoDown(ModChannel &chn, ModCommand::PARAM param) const
{
MPT_ASSERT(!chn.HasCustomTuning());
if(GetType() == MOD_TYPE_XM)
{
// FT2 compatibility: E1x / E2x / X1x / X2x memory is not linked
// Test case: Porta-LinkMem.xm
if(param) chn.nOldFinePortaUpDown = (chn.nOldFinePortaUpDown & 0xF0) | (param & 0x0F); else param = (chn.nOldFinePortaUpDown & 0x0F);
} else if(GetType() == MOD_TYPE_MT2)
{
if(param) chn.nOldFinePortaUpDown = param; else param = chn.nOldFinePortaUpDown;
}
if(chn.isFirstTick && chn.nPeriod && param)
{
DoFreqSlide(chn, chn.nPeriod, param * -4);
if(chn.nPeriod > 0xFFFF && !m_playBehaviour[kPeriodsAreHertz] && (!m_SongFlags[SONG_LINEARSLIDES] || GetType() == MOD_TYPE_XM))
chn.nPeriod = 0xFFFF;
}
}
void CSoundFile::ExtraFinePortamentoUp(ModChannel &chn, ModCommand::PARAM param) const
{
MPT_ASSERT(!chn.HasCustomTuning());
if(GetType() == MOD_TYPE_XM)
{
// FT2 compatibility: E1x / E2x / X1x / X2x memory is not linked
// Test case: Porta-LinkMem.xm
if(param) chn.nOldExtraFinePortaUpDown = (chn.nOldExtraFinePortaUpDown & 0x0F) | (param << 4); else param = (chn.nOldExtraFinePortaUpDown >> 4);
} else if(GetType() == MOD_TYPE_MT2)
{
if(param) chn.nOldFinePortaUpDown = param; else param = chn.nOldFinePortaUpDown;
}
if(chn.isFirstTick && chn.nPeriod && param)
DoFreqSlide(chn, chn.nPeriod, param);
}
void CSoundFile::ExtraFinePortamentoDown(ModChannel &chn, ModCommand::PARAM param) const
{
MPT_ASSERT(!chn.HasCustomTuning());
if(GetType() == MOD_TYPE_XM)
{
// FT2 compatibility: E1x / E2x / X1x / X2x memory is not linked
// Test case: Porta-LinkMem.xm
if(param) chn.nOldExtraFinePortaUpDown = (chn.nOldExtraFinePortaUpDown & 0xF0) | (param & 0x0F); else param = (chn.nOldExtraFinePortaUpDown & 0x0F);
} else if(GetType() == MOD_TYPE_MT2)
{
if(param) chn.nOldFinePortaUpDown = param; else param = chn.nOldFinePortaUpDown;
}
if(chn.isFirstTick && chn.nPeriod && param)
{
DoFreqSlide(chn, chn.nPeriod, -static_cast<int32>(param));
if(chn.nPeriod > 0xFFFF && !m_playBehaviour[kPeriodsAreHertz] && (!m_SongFlags[SONG_LINEARSLIDES] || GetType() == MOD_TYPE_XM))
chn.nPeriod = 0xFFFF;
}
}
void CSoundFile::SetFinetune(CHANNELINDEX channel, PlayState &playState, bool isSmooth) const
{
ModChannel &chn = playState.Chn[channel];
int16 newTuning = mpt::saturate_cast<int16>(static_cast<int32>(CalculateXParam(playState.m_nPattern, playState.m_nRow, channel, nullptr)) - 0x8000);
if(isSmooth)
{
const int32 ticksLeft = playState.TicksOnRow() - playState.m_nTickCount;
if(ticksLeft > 1)
{
const int32 step = (newTuning - chn.microTuning) / ticksLeft;
newTuning = mpt::saturate_cast<int16>(chn.microTuning + step);
}
}
chn.microTuning = newTuning;
}
// Implemented for IMF / PTM / OKT compatibility, can't actually save this in any formats
// Slide up / down every x ticks by y semitones
// Oktalyzer: Slide down on first tick only, or on every tick
void CSoundFile::NoteSlide(ModChannel &chn, uint32 param, bool slideUp, bool retrig) const
{
if(m_SongFlags[SONG_FIRSTTICK])
{
if(param & 0xF0)
chn.noteSlideParam = static_cast<uint8>(param & 0xF0) | (chn.noteSlideParam & 0x0F);
if(param & 0x0F)
chn.noteSlideParam = (chn.noteSlideParam & 0xF0) | static_cast<uint8>(param & 0x0F);
chn.noteSlideCounter = (chn.noteSlideParam >> 4);
}
bool doTrigger = false;
if(GetType() == MOD_TYPE_OKT)
doTrigger = ((chn.noteSlideParam & 0xF0) == 0x10) || m_SongFlags[SONG_FIRSTTICK];
else
doTrigger = !m_SongFlags[SONG_FIRSTTICK] && (--chn.noteSlideCounter == 0);
if(doTrigger)
{
const uint8 speed = (chn.noteSlideParam >> 4), steps = (chn.noteSlideParam & 0x0F);
chn.noteSlideCounter = speed;
// update it
const int32 delta = (slideUp ? steps : -steps);
if(chn.HasCustomTuning())
chn.m_PortamentoFineSteps += delta * chn.pModInstrument->pTuning->GetFineStepCount();
else
chn.nPeriod = GetPeriodFromNote(delta + GetNoteFromPeriod(chn.nPeriod, chn.nFineTune, chn.nC5Speed), chn.nFineTune, chn.nC5Speed);
if(retrig)
chn.position.Set(0);
}
}
std::pair<uint16, bool> CSoundFile::GetVolCmdTonePorta(const ModCommand &m, uint32 startTick) const
{
if(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_AMS | MOD_TYPE_DMF | MOD_TYPE_DBM | MOD_TYPE_IMF | MOD_TYPE_PSM | MOD_TYPE_J2B | MOD_TYPE_ULT | MOD_TYPE_OKT | MOD_TYPE_MT2 | MOD_TYPE_MDL))
{
return {ImpulseTrackerPortaVolCmd[m.vol & 0x0F], false};
} else
{
bool clearEffectColumn = false;
uint16 vol = m.vol;
if(m.command == CMD_TONEPORTAMENTO && GetType() == MOD_TYPE_XM)
{
// Yes, FT2 is *that* weird. If there is a Mx command in the volume column
// and a normal 3xx command, the 3xx command is ignored but the Mx command's
// effectiveness is doubled.
// Test case: TonePortamentoMemory.xm
clearEffectColumn = true;
vol *= 2;
}
// FT2 compatibility: If there's a portamento and a note delay, execute the portamento, but don't update the parameter
// Test case: PortaDelay.xm
if(m_playBehaviour[kFT2PortaDelay] && startTick != 0)
return {uint16(0), clearEffectColumn};
else
return {static_cast<uint16>(vol * 16), clearEffectColumn};
}
}
// Portamento Slide
void CSoundFile::TonePortamento(ModChannel &chn, uint16 param) const
{
chn.dwFlags.set(CHN_PORTAMENTO);
//IT compatibility 03: Share effect memory with portamento up/down
if((!m_SongFlags[SONG_ITCOMPATGXX] && m_playBehaviour[kITPortaMemoryShare]) || GetType() == MOD_TYPE_PLM)
{
if(param == 0) param = chn.nOldPortaUp;
chn.nOldPortaUp = chn.nOldPortaDown = static_cast<uint8>(param);
}
if(param)
chn.portamentoSlide = param;
if(chn.HasCustomTuning())
{
//Behavior: Param tells number of finesteps(or 'fullsteps'(notes) with glissando)
//to slide per row(not per tick).
if(chn.portamentoSlide == 0)
return;
const int32 oldPortamentoTickSlide = (m_PlayState.m_nTickCount != 0) ? chn.m_PortamentoTickSlide : 0;
int32 delta = chn.portamentoSlide;
if(chn.nPortamentoDest < 0)
delta = -delta;
chn.m_PortamentoTickSlide = static_cast<int32>((m_PlayState.m_nTickCount + 1.0) * delta / m_PlayState.m_nMusicSpeed);
if(chn.dwFlags[CHN_GLISSANDO])
{
chn.m_PortamentoTickSlide *= chn.pModInstrument->pTuning->GetFineStepCount() + 1;
//With glissando interpreting param as notes instead of finesteps.
}
const int32 slide = chn.m_PortamentoTickSlide - oldPortamentoTickSlide;
if(std::abs(chn.nPortamentoDest) <= std::abs(slide))
{
if(chn.nPortamentoDest != 0)
{
chn.m_PortamentoFineSteps += chn.nPortamentoDest;
chn.nPortamentoDest = 0;
chn.m_CalculateFreq = true;
}
} else
{
chn.m_PortamentoFineSteps += slide;
chn.nPortamentoDest -= slide;
chn.m_CalculateFreq = true;
}
return;
}
bool doPorta = !chn.isFirstTick
|| (GetType() & (MOD_TYPE_DBM | MOD_TYPE_669))
|| (m_PlayState.m_nMusicSpeed == 1 && m_playBehaviour[kSlidesAtSpeed1])
|| (GetType() == MOD_TYPE_MED && m_SongFlags[SONG_FASTVOLSLIDES]);
int32 delta = chn.portamentoSlide;
if(GetType() == MOD_TYPE_PLM && delta >= 0xF0)
{
delta -= 0xF0;
doPorta = chn.isFirstTick;
}
if(chn.nPeriod && chn.nPortamentoDest && doPorta)
{
delta *= (GetType() == MOD_TYPE_669) ? 2 : 4;
if(!PeriodsAreFrequencies())
delta = -delta;
if(chn.nPeriod < chn.nPortamentoDest || chn.portaTargetReached)
{
DoFreqSlide(chn, chn.nPeriod, delta, true);
if(chn.nPeriod > chn.nPortamentoDest)
chn.nPeriod = chn.nPortamentoDest;
} else if(chn.nPeriod > chn.nPortamentoDest)
{
DoFreqSlide(chn, chn.nPeriod, -delta, true);
if(chn.nPeriod < chn.nPortamentoDest)
chn.nPeriod = chn.nPortamentoDest;
// FT2 compatibility: Reaching portamento target from below forces subsequent portamentos on the same note to use the logic for reaching the note from above instead.
// Test case: PortaResetDirection.xm
if(chn.nPeriod == chn.nPortamentoDest && m_playBehaviour[kFT2PortaResetDirection])
chn.portaTargetReached = true;
}
}
// IT compatibility 23. Portamento with no note
// ProTracker also disables portamento once the target is reached.
// Test case: PortaTarget.mod
if(chn.nPeriod == chn.nPortamentoDest && (m_playBehaviour[kITPortaTargetReached] || GetType() == MOD_TYPE_MOD))
chn.nPortamentoDest = 0;
}
void CSoundFile::Vibrato(ModChannel &chn, uint32 param) const
{
if (param & 0x0F) chn.nVibratoDepth = (param & 0x0F) * 4;
if (param & 0xF0) chn.nVibratoSpeed = (param >> 4) & 0x0F;
chn.dwFlags.set(CHN_VIBRATO);
}
void CSoundFile::FineVibrato(ModChannel &chn, uint32 param) const
{
if (param & 0x0F) chn.nVibratoDepth = param & 0x0F;
if (param & 0xF0) chn.nVibratoSpeed = (param >> 4) & 0x0F;
chn.dwFlags.set(CHN_VIBRATO);
// ST3 compatibility: Do not distinguish between vibrato types in effect memory
// Test case: VibratoTypeChange.s3m
if(m_playBehaviour[kST3VibratoMemory] && (param & 0x0F))
{
chn.nVibratoDepth *= 4u;
}
}
void CSoundFile::Panbrello(ModChannel &chn, uint32 param) const
{
if (param & 0x0F) chn.nPanbrelloDepth = param & 0x0F;
if (param & 0xF0) chn.nPanbrelloSpeed = (param >> 4) & 0x0F;
}
void CSoundFile::Panning(ModChannel &chn, uint32 param, PanningType panBits) const
{
// No panning in ProTracker mode
if(m_playBehaviour[kMODIgnorePanning])
{
return;
}
// IT Compatibility (and other trackers as well): panning disables surround (unless panning in rear channels is enabled, which is not supported by the original trackers anyway)
if (!m_SongFlags[SONG_SURROUNDPAN] && (panBits == Pan8bit || m_playBehaviour[kPanOverride]))
{
chn.dwFlags.reset(CHN_SURROUND);
}
if(panBits == Pan4bit)
{
// 0...15 panning
chn.nPan = (param * 256 + 8) / 15;
} else if(panBits == Pan6bit)
{
// 0...64 panning
if(param > 64) param = 64;
chn.nPan = param * 4;
} else
{
if(!(GetType() & (MOD_TYPE_S3M | MOD_TYPE_DSM | MOD_TYPE_AMF0 | MOD_TYPE_AMF | MOD_TYPE_MTM)))
{
// Real 8-bit panning
chn.nPan = param;
} else
{
// 7-bit panning + surround
if(param <= 0x80)
{
chn.nPan = param << 1;
} else if(param == 0xA4)
{
chn.dwFlags.set(CHN_SURROUND);
chn.nPan = 0x80;
}
}
}
chn.dwFlags.set(CHN_FASTVOLRAMP);
chn.nRestorePanOnNewNote = 0;
//IT compatibility 20. Set pan overrides random pan
if(m_playBehaviour[kPanOverride])
{
chn.nPanSwing = 0;
chn.nPanbrelloOffset = 0;
}
}
void CSoundFile::VolumeSlide(ModChannel &chn, ModCommand::PARAM param) const
{
if (param)
chn.nOldVolumeSlide = param;
else
param = chn.nOldVolumeSlide;
if((GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM | MOD_TYPE_MT2 | MOD_TYPE_MED | MOD_TYPE_DIGI | MOD_TYPE_STP | MOD_TYPE_DTM)))
{
// MOD / XM nibble priority
if((param & 0xF0) != 0)
{
param &= 0xF0;
} else
{
param &= 0x0F;
}
}
int newVolume = chn.nVolume;
if(!(GetType() & (MOD_TYPE_MOD | MOD_TYPE_XM | MOD_TYPE_AMF0 | MOD_TYPE_MED | MOD_TYPE_DIGI)))
{
if ((param & 0x0F) == 0x0F) //Fine upslide or slide -15
{
if (param & 0xF0) //Fine upslide
{
FineVolumeUp(chn, (param >> 4), false);
return;
} else //Slide -15
{
if(chn.isFirstTick && !m_SongFlags[SONG_FASTVOLSLIDES])
{
newVolume -= 0x0F * 4;
}
}
} else
if ((param & 0xF0) == 0xF0) //Fine downslide or slide +15
{
if (param & 0x0F) //Fine downslide
{
FineVolumeDown(chn, (param & 0x0F), false);
return;
} else //Slide +15
{
if(chn.isFirstTick && !m_SongFlags[SONG_FASTVOLSLIDES])
{
newVolume += 0x0F * 4;
}
}
}
}
if(!chn.isFirstTick || m_SongFlags[SONG_FASTVOLSLIDES] || (m_PlayState.m_nMusicSpeed == 1 && GetType() == MOD_TYPE_DBM))
{
// IT compatibility: Ignore slide commands with both nibbles set.
if (param & 0x0F)
{
if(!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) || (param & 0xF0) == 0)
newVolume -= (int)((param & 0x0F) * 4);
}
else
{
newVolume += (int)((param & 0xF0) >> 2);
}
if (GetType() == MOD_TYPE_MOD) chn.dwFlags.set(CHN_FASTVOLRAMP);
}
newVolume = Clamp(newVolume, 0, 256);
chn.nVolume = newVolume;
}
void CSoundFile::PanningSlide(ModChannel &chn, ModCommand::PARAM param, bool memory) const
{
if(memory)
{
// FT2 compatibility: Use effect memory (lxx and rxx in XM shouldn't use effect memory).
// Test case: PanSlideMem.xm
if(param)
chn.nOldPanSlide = param;
else
param = chn.nOldPanSlide;
}
if((GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2)))
{
// XM nibble priority
if((param & 0xF0) != 0)
{
param &= 0xF0;
} else
{
param &= 0x0F;
}
}
int32 nPanSlide = 0;
if(!(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2)))
{
if (((param & 0x0F) == 0x0F) && (param & 0xF0))
{
if(m_SongFlags[SONG_FIRSTTICK])
{
param = (param & 0xF0) / 4u;
nPanSlide = - (int)param;
}
} else if (((param & 0xF0) == 0xF0) && (param & 0x0F))
{
if(m_SongFlags[SONG_FIRSTTICK])
{
nPanSlide = (param & 0x0F) * 4u;
}
} else if(!m_SongFlags[SONG_FIRSTTICK])
{
if (param & 0x0F)
{
// IT compatibility: Ignore slide commands with both nibbles set.
if(!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) || (param & 0xF0) == 0)
nPanSlide = (int)((param & 0x0F) * 4u);
} else
{
nPanSlide = -(int)((param & 0xF0) / 4u);
}
}
} else
{
if(!m_SongFlags[SONG_FIRSTTICK])
{
if (param & 0xF0)
{
nPanSlide = (int)((param & 0xF0) / 4u);
} else
{
nPanSlide = -(int)((param & 0x0F) * 4u);
}
// FT2 compatibility: FT2's panning slide is like IT's fine panning slide (not as deep)
if(m_playBehaviour[kFT2PanSlide])
nPanSlide /= 4;
}
}
if (nPanSlide)
{
nPanSlide += chn.nPan;
nPanSlide = Clamp(nPanSlide, 0, 256);
chn.nPan = nPanSlide;
chn.nRestorePanOnNewNote = 0;
}
}
void CSoundFile::FineVolumeUp(ModChannel &chn, ModCommand::PARAM param, bool volCol) const
{
if(GetType() == MOD_TYPE_XM)
{
// FT2 compatibility: EAx / EBx memory is not linked
// Test case: FineVol-LinkMem.xm
if(param) chn.nOldFineVolUpDown = (param << 4) | (chn.nOldFineVolUpDown & 0x0F); else param = (chn.nOldFineVolUpDown >> 4);
} else if(volCol)
{
if(param) chn.nOldVolParam = param; else param = chn.nOldVolParam;
} else
{
if(param) chn.nOldFineVolUpDown = param; else param = chn.nOldFineVolUpDown;
}
if(chn.isFirstTick)
{
chn.nVolume += param * 4;
if(chn.nVolume > 256) chn.nVolume = 256;
if(GetType() & MOD_TYPE_MOD) chn.dwFlags.set(CHN_FASTVOLRAMP);
}
}
void CSoundFile::FineVolumeDown(ModChannel &chn, ModCommand::PARAM param, bool volCol) const
{
if(GetType() == MOD_TYPE_XM)
{
// FT2 compatibility: EAx / EBx memory is not linked
// Test case: FineVol-LinkMem.xm
if(param) chn.nOldFineVolUpDown = param | (chn.nOldFineVolUpDown & 0xF0); else param = (chn.nOldFineVolUpDown & 0x0F);
} else if(volCol)
{
if(param) chn.nOldVolParam = param; else param = chn.nOldVolParam;
} else
{
if(param) chn.nOldFineVolUpDown = param; else param = chn.nOldFineVolUpDown;
}
if(chn.isFirstTick)
{
chn.nVolume -= param * 4;
if(chn.nVolume < 0) chn.nVolume = 0;
if(GetType() & MOD_TYPE_MOD) chn.dwFlags.set(CHN_FASTVOLRAMP);
}
}
void CSoundFile::Tremolo(ModChannel &chn, uint32 param) const
{
if (param & 0x0F) chn.nTremoloDepth = (param & 0x0F) << 2;
if (param & 0xF0) chn.nTremoloSpeed = (param >> 4) & 0x0F;
chn.dwFlags.set(CHN_TREMOLO);
}
void CSoundFile::ChannelVolSlide(ModChannel &chn, ModCommand::PARAM param) const
{
int32 nChnSlide = 0;
if (param) chn.nOldChnVolSlide = param; else param = chn.nOldChnVolSlide;
if (((param & 0x0F) == 0x0F) && (param & 0xF0))
{
if(m_SongFlags[SONG_FIRSTTICK]) nChnSlide = param >> 4;
} else if (((param & 0xF0) == 0xF0) && (param & 0x0F))
{
if(m_SongFlags[SONG_FIRSTTICK]) nChnSlide = - (int)(param & 0x0F);
} else
{
if(!m_SongFlags[SONG_FIRSTTICK])
{
if (param & 0x0F)
{
if(!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_J2B | MOD_TYPE_DBM)) || (param & 0xF0) == 0)
nChnSlide = -(int)(param & 0x0F);
} else
{
nChnSlide = (int)((param & 0xF0) >> 4);
}
}
}
if (nChnSlide)
{
nChnSlide += chn.nGlobalVol;
nChnSlide = Clamp(nChnSlide, 0, 64);
chn.nGlobalVol = nChnSlide;
}
}
void CSoundFile::ExtendedMODCommands(CHANNELINDEX nChn, ModCommand::PARAM param)
{
ModChannel &chn = m_PlayState.Chn[nChn];
uint8 command = param & 0xF0;
param &= 0x0F;
switch(command)
{
// E0x: Set Filter
case 0x00:
for(CHANNELINDEX channel = 0; channel < GetNumChannels(); channel++)
{
m_PlayState.Chn[channel].dwFlags.set(CHN_AMIGAFILTER, !(param & 1));
}
break;
// E1x: Fine Portamento Up
case 0x10: if ((param) || (GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2))) FinePortamentoUp(chn, param); break;
// E2x: Fine Portamento Down
case 0x20: if ((param) || (GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2))) FinePortamentoDown(chn, param); break;
// E3x: Set Glissando Control
case 0x30: chn.dwFlags.set(CHN_GLISSANDO, param != 0); break;
// E4x: Set Vibrato WaveForm
case 0x40: chn.nVibratoType = param & 0x07; break;
// E5x: Set FineTune
case 0x50: if(!m_SongFlags[SONG_FIRSTTICK])
break;
if(GetType() & (MOD_TYPE_MOD | MOD_TYPE_DIGI | MOD_TYPE_AMF0 | MOD_TYPE_MED))
{
chn.nFineTune = MOD2XMFineTune(param);
if(chn.nPeriod && chn.rowCommand.IsNote()) chn.nPeriod = GetPeriodFromNote(chn.nNote, chn.nFineTune, chn.nC5Speed);
} else if(GetType() == MOD_TYPE_MTM)
{
if(chn.rowCommand.IsNote() && chn.pModSample != nullptr)
{
// Effect is permanent in MultiTracker
const_cast<ModSample *>(chn.pModSample)->nFineTune = param;
chn.nFineTune = param;
if(chn.nPeriod) chn.nPeriod = GetPeriodFromNote(chn.nNote, chn.nFineTune, chn.nC5Speed);
}
} else if(chn.rowCommand.IsNote())
{
chn.nFineTune = MOD2XMFineTune(param - 8);
if(chn.nPeriod) chn.nPeriod = GetPeriodFromNote(chn.nNote, chn.nFineTune, chn.nC5Speed);
}
break;
// E6x: Pattern Loop
case 0x60:
if(m_SongFlags[SONG_FIRSTTICK])
PatternLoop(m_PlayState, chn, param & 0x0F);
break;
// E7x: Set Tremolo WaveForm
case 0x70: chn.nTremoloType = param & 0x07; break;
// E8x: Set 4-bit Panning
case 0x80:
if(m_SongFlags[SONG_FIRSTTICK])
{
Panning(chn, param, Pan4bit);
}
break;
// E9x: Retrig
case 0x90: RetrigNote(nChn, param); break;
// EAx: Fine Volume Up
case 0xA0: if ((param) || (GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2))) FineVolumeUp(chn, param, false); break;
// EBx: Fine Volume Down
case 0xB0: if ((param) || (GetType() & (MOD_TYPE_XM|MOD_TYPE_MT2))) FineVolumeDown(chn, param, false); break;
// ECx: Note Cut
case 0xC0: NoteCut(nChn, param, false); break;
// EDx: Note Delay
// EEx: Pattern Delay
case 0xF0:
if(GetType() == MOD_TYPE_MOD) // MOD: Invert Loop
{
chn.nEFxSpeed = param;
if(m_SongFlags[SONG_FIRSTTICK]) InvertLoop(chn);
} else // XM: Set Active Midi Macro
{
chn.nActiveMacro = param;
}
break;
}
}
void CSoundFile::ExtendedS3MCommands(CHANNELINDEX nChn, ModCommand::PARAM param)
{
ModChannel &chn = m_PlayState.Chn[nChn];
uint8 command = param & 0xF0;
param &= 0x0F;
switch(command)
{
// S0x: Set Filter
// S1x: Set Glissando Control
case 0x10: chn.dwFlags.set(CHN_GLISSANDO, param != 0); break;
// S2x: Set FineTune
case 0x20: if(!m_SongFlags[SONG_FIRSTTICK])
break;
if(chn.HasCustomTuning())
{
chn.nFineTune = param - 8;
chn.m_CalculateFreq = true;
} else if(GetType() != MOD_TYPE_669)
{
chn.nC5Speed = S3MFineTuneTable[param];
chn.nFineTune = MOD2XMFineTune(param);
if(chn.nPeriod)
chn.nPeriod = GetPeriodFromNote(chn.nNote, chn.nFineTune, chn.nC5Speed);
} else if(chn.pModSample != nullptr)
{
chn.nC5Speed = chn.pModSample->nC5Speed + param * 80;
}
break;
// S3x: Set Vibrato Waveform
case 0x30: if(GetType() == MOD_TYPE_S3M)
{
chn.nVibratoType = param & 0x03;
} else
{
// IT compatibility: Ignore waveform types > 3
if(m_playBehaviour[kITVibratoTremoloPanbrello])
chn.nVibratoType = (param < 0x04) ? param : 0;
else
chn.nVibratoType = param & 0x07;
}
break;
// S4x: Set Tremolo Waveform
case 0x40: if(GetType() == MOD_TYPE_S3M)
{
chn.nTremoloType = param & 0x03;
} else
{
// IT compatibility: Ignore waveform types > 3
if(m_playBehaviour[kITVibratoTremoloPanbrello])
chn.nTremoloType = (param < 0x04) ? param : 0;
else
chn.nTremoloType = param & 0x07;
}
break;
// S5x: Set Panbrello Waveform
case 0x50:
// IT compatibility: Ignore waveform types > 3
if(m_playBehaviour[kITVibratoTremoloPanbrello])
{
chn.nPanbrelloType = (param < 0x04) ? param : 0;
chn.nPanbrelloPos = 0;
} else
{
chn.nPanbrelloType = param & 0x07;
}
break;
// S6x: Pattern Delay for x frames
case 0x60:
if(m_SongFlags[SONG_FIRSTTICK] && m_PlayState.m_nTickCount == 0)
{
// Tick delays are added up.
// Scream Tracker 3 does actually not support this command.
// We'll use the same behaviour as for Impulse Tracker, as we can assume that
// most S3Ms that make use of this command were made with Impulse Tracker.
// MPT added this command to the XM format through the X6x effect, so we will use
// the same behaviour here as well.
// Test cases: PatternDelays.it, PatternDelays.s3m, PatternDelays.xm
m_PlayState.m_nFrameDelay += param;
}
break;
// S7x: Envelope Control / Instrument Control
case 0x70: if(!m_SongFlags[SONG_FIRSTTICK]) break;
switch(param)
{
case 0:
case 1:
case 2:
{
for (CHANNELINDEX i = m_nChannels; i < MAX_CHANNELS; i++)
{
ModChannel &bkChn = m_PlayState.Chn[i];
if (bkChn.nMasterChn == nChn + 1)
{
if (param == 1)
{
KeyOff(bkChn);
if(bkChn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->NoteOff(i);
} else if (param == 2)
{
bkChn.dwFlags.set(CHN_NOTEFADE);
if(bkChn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->NoteOff(i);
} else
{
bkChn.dwFlags.set(CHN_NOTEFADE);
bkChn.nFadeOutVol = 0;
if(bkChn.dwFlags[CHN_ADLIB] && m_opl)
m_opl->NoteCut(i);
}
#ifndef NO_PLUGINS
const ModInstrument *pIns = bkChn.pModInstrument;
IMixPlugin *pPlugin;
if(pIns != nullptr && pIns->nMixPlug && (pPlugin = m_MixPlugins[pIns->nMixPlug - 1].pMixPlugin) != nullptr)
{
pPlugin->MidiCommand(*pIns, bkChn.nNote + NOTE_MAX_SPECIAL, 0, nChn);
}
#endif // NO_PLUGINS
}
}
}
break;
default: // S73-S7E
chn.InstrumentControl(param, *this);
break;
}
break;
// S8x: Set 4-bit Panning
case 0x80:
if(m_SongFlags[SONG_FIRSTTICK])
{
Panning(chn, param, Pan4bit);
}
break;
// S9x: Sound Control
case 0x90: ExtendedChannelEffect(chn, param); break;
// SAx: Set 64k Offset
case 0xA0: if(m_SongFlags[SONG_FIRSTTICK])
{
chn.nOldHiOffset = static_cast<uint8>(param);
if (!m_playBehaviour[kITHighOffsetNoRetrig] && chn.rowCommand.IsNote())
{
SmpLength pos = param << 16;
if (pos < chn.nLength) chn.position.SetInt(pos);
}
}
break;
// SBx: Pattern Loop
case 0xB0:
if(m_SongFlags[SONG_FIRSTTICK])
PatternLoop(m_PlayState, chn, param & 0x0F);
break;
// SCx: Note Cut
case 0xC0:
if(param == 0)
{
//IT compatibility 22. SC0 == SC1
if(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))
param = 1;
// ST3 doesn't cut notes with SC0
else if(GetType() == MOD_TYPE_S3M)
return;
}
// S3M/IT compatibility: Note Cut really cuts notes and does not just mute them (so that following volume commands could restore the sample)
// Test case: scx.it
NoteCut(nChn, param, m_playBehaviour[kITSCxStopsSample] || GetType() == MOD_TYPE_S3M);
break;
// SDx: Note Delay
// SEx: Pattern Delay for x rows
// SFx: S3M: Not used, IT: Set Active Midi Macro
case 0xF0:
if(GetType() != MOD_TYPE_S3M)
{
chn.nActiveMacro = static_cast<uint8>(param);
}
break;
}
}
void CSoundFile::ExtendedChannelEffect(ModChannel &chn, uint32 param)
{
// S9x and X9x commands (S3M/XM/IT only)
if(!m_SongFlags[SONG_FIRSTTICK]) return;
switch(param & 0x0F)
{
// S90: Surround Off
case 0x00: chn.dwFlags.reset(CHN_SURROUND); break;
// S91: Surround On
case 0x01: chn.dwFlags.set(CHN_SURROUND); chn.nPan = 128; break;
////////////////////////////////////////////////////////////
// ModPlug Extensions
// S98: Reverb Off
case 0x08:
chn.dwFlags.reset(CHN_REVERB);
chn.dwFlags.set(CHN_NOREVERB);
break;
// S99: Reverb On
case 0x09:
chn.dwFlags.reset(CHN_NOREVERB);
chn.dwFlags.set(CHN_REVERB);
break;
// S9A: 2-Channels surround mode
case 0x0A:
m_SongFlags.reset(SONG_SURROUNDPAN);
break;
// S9B: 4-Channels surround mode
case 0x0B:
m_SongFlags.set(SONG_SURROUNDPAN);
break;
// S9C: IT Filter Mode
case 0x0C:
m_SongFlags.reset(SONG_MPTFILTERMODE);
break;
// S9D: MPT Filter Mode
case 0x0D:
m_SongFlags.set(SONG_MPTFILTERMODE);
break;
// S9E: Go forward
case 0x0E:
chn.dwFlags.reset(CHN_PINGPONGFLAG);
break;
// S9F: Go backward (and set playback position to the end if sample just started)
case 0x0F:
if(chn.position.IsZero() && chn.nLength && (chn.rowCommand.IsNote() || !chn.dwFlags[CHN_LOOP]))
{
chn.position.Set(chn.nLength - 1, SamplePosition::fractMax);
}
chn.dwFlags.set(CHN_PINGPONGFLAG);
break;
}
}
void CSoundFile::InvertLoop(ModChannel &chn)
{
// EFx implementation for MOD files (PT 1.1A and up: Invert Loop)
// This effect trashes samples. Thanks to 8bitbubsy for making this work. :)
if(GetType() != MOD_TYPE_MOD || chn.nEFxSpeed == 0)
return;
ModSample *pModSample = const_cast<ModSample *>(chn.pModSample);
if(pModSample == nullptr || !pModSample->HasSampleData() || !pModSample->uFlags[CHN_LOOP | CHN_SUSTAINLOOP])
return;
chn.nEFxDelay += ModEFxTable[chn.nEFxSpeed & 0x0F];
if(chn.nEFxDelay < 128)
return;
chn.nEFxDelay = 0;
const SmpLength loopStart = pModSample->uFlags[CHN_LOOP] ? pModSample->nLoopStart : pModSample->nSustainStart;
const SmpLength loopEnd = pModSample->uFlags[CHN_LOOP] ? pModSample->nLoopEnd : pModSample->nSustainEnd;
if(++chn.nEFxOffset >= loopEnd - loopStart)
chn.nEFxOffset = 0;
// TRASH IT!!! (Yes, the sample!)
const uint8 bps = pModSample->GetBytesPerSample();
uint8 *begin = mpt::byte_cast<uint8 *>(pModSample->sampleb()) + (loopStart + chn.nEFxOffset) * bps;
for(auto &sample : mpt::as_span(begin, bps))
{
sample = ~sample;
}
pModSample->PrecomputeLoops(*this, false);
}
// Process a MIDI Macro.
// Parameters:
// playState: The playback state to operate on.
// nChn: Mod channel to apply macro on
// isSmooth: If true, internal macros are interpolated between two rows
// macro: MIDI Macro string to process
// param: Parameter for parametric macros (Zxx / \xx parameter)
// plugin: Plugin to send MIDI message to (if not specified but needed, it is autodetected)
void CSoundFile::ProcessMIDIMacro(PlayState &playState, CHANNELINDEX nChn, bool isSmooth, const MIDIMacroConfigData::Macro &macro, uint8 param, PLUGINDEX plugin)
{
playState.m_midiMacroScratchSpace.resize(macro.Length() + 1);
auto out = mpt::as_span(playState.m_midiMacroScratchSpace);
ParseMIDIMacro(playState, nChn, isSmooth, macro, out, param, plugin);
// Macro string has been parsed and translated, now send the message(s)...
uint32 outSize = static_cast<uint32>(out.size());
uint32 sendPos = 0;
uint8 runningStatus = 0;
while(sendPos < out.size())
{
uint32 sendLen = 0;
if(out[sendPos] == 0xF0)
{
// SysEx start
if((outSize - sendPos >= 4) && (out[sendPos + 1] == 0xF0 || out[sendPos + 1] == 0xF1))
{
// Internal macro (normal (F0F0) or extended (F0F1)), 4 bytes long
sendLen = 4;
} else
{
// SysEx message, find end of message
for(uint32 i = sendPos + 1; i < outSize; i++)
{
if(out[i] == 0xF7)
{
// Found end of SysEx message
sendLen = i - sendPos + 1;
break;
}
}
if(sendLen == 0)
{
// Didn't find end, so "invent" end of SysEx message
out[outSize++] = 0xF7;
sendLen = outSize - sendPos;
}
}
} else if(!(out[sendPos] & 0x80))
{
// Missing status byte? Try inserting running status
if(runningStatus != 0)
{
sendPos--;
out[sendPos] = runningStatus;
} else
{
// No running status to re-use; skip this byte
sendPos++;
}
continue;
} else
{
// Other MIDI messages
sendLen = std::min(static_cast<uint32>(MIDIEvents::GetEventLength(out[sendPos])), outSize - sendPos);
}
if(sendLen == 0)
break;
if(out[sendPos] < 0xF0)
{
runningStatus = out[sendPos];
}
const auto midiMsg = out.subspan(sendPos, sendLen);
SendMIDIData(playState, nChn, isSmooth, midiMsg, plugin);
sendPos += sendLen;
}
}
void CSoundFile::ParseMIDIMacro(PlayState &playState, CHANNELINDEX nChn, bool isSmooth, const mpt::span<const char> macro, mpt::span<uint8> &out, uint8 param, PLUGINDEX plugin) const
{
ModChannel &chn = playState.Chn[nChn];
const ModInstrument *pIns = chn.pModInstrument;
const uint8 lastZxxParam = chn.lastZxxParam; // always interpolate based on original value in case z appears multiple times in macro string
uint8 updateZxxParam = 0xFF; // avoid updating lastZxxParam immediately if macro contains both internal and external MIDI message
bool firstNibble = true;
size_t outPos = 0; // output buffer position, which also equals the number of complete bytes
for(size_t pos = 0; pos < macro.size() && outPos < out.size(); pos++)
{
bool isNibble = false; // did we parse a nibble or a byte value?
uint8 data = 0; // data that has just been parsed
// Parse next macro byte... See Impulse Tracker's MIDI.TXT for detailed information on each possible character.
if(macro[pos] >= '0' && macro[pos] <= '9')
{
isNibble = true;
data = static_cast<uint8>(macro[pos] - '0');
} else if(macro[pos] >= 'A' && macro[pos] <= 'F')
{
isNibble = true;
data = static_cast<uint8>(macro[pos] - 'A' + 0x0A);
} else if(macro[pos] == 'c')
{
// MIDI channel
isNibble = true;
data = 0xFF;
#ifndef NO_PLUGINS
const PLUGINDEX plug = (plugin != 0) ? plugin : GetBestPlugin(playState, nChn, PrioritiseChannel, EvenIfMuted);
if(plug > 0 && plug <= MAX_MIXPLUGINS)
{
auto midiPlug = dynamic_cast<const IMidiPlugin *>(m_MixPlugins[plug - 1u].pMixPlugin);
if(midiPlug)
data = midiPlug->GetMidiChannel(playState.Chn[nChn], nChn);
}
#endif // NO_PLUGINS
if(data == 0xFF)
{
// Fallback if no plugin was found
if(pIns)
data = pIns->GetMIDIChannel(playState.Chn[nChn], nChn);
else
data = 0;
}
} else if(macro[pos] == 'n')
{
// Last triggered note
if(ModCommand::IsNote(chn.nLastNote))
{
data = chn.nLastNote - NOTE_MIN;
}
} else if(macro[pos] == 'v')
{
// Velocity
// This is "almost" how IT does it - apparently, IT seems to lag one row behind on global volume or channel volume changes.
const int swing = (m_playBehaviour[kITSwingBehaviour] || m_playBehaviour[kMPTOldSwingBehaviour]) ? chn.nVolSwing : 0;
const int vol = Util::muldiv((chn.nVolume + swing) * m_PlayState.m_nGlobalVolume, chn.nGlobalVol * chn.nInsVol, 1 << 20);
data = static_cast<uint8>(Clamp(vol / 2, 1, 127));
//data = (unsigned char)std::min((chn.nVolume * chn.nGlobalVol * m_nGlobalVolume) >> (1 + 6 + 8), 127);
} else if(macro[pos] == 'u')
{
// Calculated volume
// Same note as with velocity applies here, but apparently also for instrument / sample volumes?
const int vol = Util::muldiv(chn.nCalcVolume * m_PlayState.m_nGlobalVolume, chn.nGlobalVol * chn.nInsVol, 1 << 26);
data = static_cast<uint8>(Clamp(vol / 2, 1, 127));
//data = (unsigned char)std::min((chn.nCalcVolume * chn.nGlobalVol * m_nGlobalVolume) >> (7 + 6 + 8), 127);
} else if(macro[pos] == 'x')
{
// Pan set
data = static_cast<uint8>(std::min(static_cast<int>(chn.nPan / 2), 127));
} else if(macro[pos] == 'y')
{
// Calculated pan
data = static_cast<uint8>(std::min(static_cast<int>(chn.nRealPan / 2), 127));
} else if(macro[pos] == 'a')
{
// High byte of bank select
if(pIns && pIns->wMidiBank)
{
data = static_cast<uint8>(((pIns->wMidiBank - 1) >> 7) & 0x7F);
}
} else if(macro[pos] == 'b')
{
// Low byte of bank select
if(pIns && pIns->wMidiBank)
{
data = static_cast<uint8>((pIns->wMidiBank - 1) & 0x7F);
}
} else if(macro[pos] == 'o')
{
// Offset (ignoring high offset)
data = static_cast<uint8>((chn.oldOffset >> 8) & 0xFF);
} else if(macro[pos] == 'h')
{
// Host channel number
data = static_cast<uint8>((nChn >= GetNumChannels() ? (chn.nMasterChn - 1) : nChn) & 0x7F);
} else if(macro[pos] == 'm')
{
// Loop direction (judging from the character, it was supposed to be loop type, though)
data = chn.dwFlags[CHN_PINGPONGFLAG] ? 1 : 0;
} else if(macro[pos] == 'p')
{
// Program select
if(pIns && pIns->nMidiProgram)
{
data = static_cast<uint8>((pIns->nMidiProgram - 1) & 0x7F);
}
} else if(macro[pos] == 'z')
{
// Zxx parameter
data = param;
if(isSmooth && chn.lastZxxParam < 0x80
&& (outPos < 3 || out[outPos - 3] != 0xF0 || out[outPos - 2] < 0xF0))
{
// Interpolation for external MIDI messages - interpolation for internal messages
// is handled separately to allow for more than 7-bit granularity where it's possible
data = static_cast<uint8>(CalculateSmoothParamChange(playState, lastZxxParam, data));
chn.lastZxxParam = data;
updateZxxParam = 0x80;
} else if(updateZxxParam == 0xFF)
{
updateZxxParam = data;
}
} else if(macro[pos] == 's')
{
// SysEx Checksum (not an original Impulse Tracker macro variable, but added for convenience)
auto startPos = outPos;
while(startPos > 0 && out[--startPos] != 0xF0);
if(outPos - startPos < 5 || out[startPos] != 0xF0)
{
continue;
}
for(auto p = startPos + 5u; p != outPos; p++)
{
data += out[p];
}
data = (~data + 1) & 0x7F;
} else
{
// Unrecognized byte (e.g. space char)
continue;
}
// Append parsed data
if(isNibble) // parsed a nibble (constant or 'c' variable)
{
if(firstNibble)
{
out[outPos] = data;
} else
{
out[outPos] = (out[outPos] << 4) | data;
outPos++;
}
firstNibble = !firstNibble;
} else // parsed a byte (variable)
{
if(!firstNibble) // From MIDI.TXT: '9n' is exactly the same as '09 n' or '9 n' -- so finish current byte first
{
outPos++;
}
out[outPos++] = data;
firstNibble = true;
}
}
if(!firstNibble)
{
// Finish current byte
outPos++;
}
if(updateZxxParam < 0x80)
chn.lastZxxParam = updateZxxParam;
out = out.first(outPos);
}
// Calculate smooth MIDI macro slide parameter for current tick.
float CSoundFile::CalculateSmoothParamChange(const PlayState &playState, float currentValue, float param)
{
MPT_ASSERT(playState.TicksOnRow() > playState.m_nTickCount);
const uint32 ticksLeft = playState.TicksOnRow() - playState.m_nTickCount;
if(ticksLeft > 1)
{
// Slide param
const float step = (param - currentValue) / static_cast<float>(ticksLeft);
return (currentValue + step);
} else
{
// On last tick, set exact value.
return param;
}
}
// Process exactly one MIDI message parsed by ProcessMIDIMacro. Returns bytes sent on success, 0 on (parse) failure.
void CSoundFile::SendMIDIData(PlayState &playState, CHANNELINDEX nChn, bool isSmooth, const mpt::span<const uint8> macro, PLUGINDEX plugin)
{
if(macro.size() < 1)
return;
// Don't do anything that modifies state outside of the playState itself.
const bool localOnly = playState.m_midiMacroEvaluationResults.has_value();
if(macro[0] == 0xFA || macro[0] == 0xFC || macro[0] == 0xFF)
{
// Start Song, Stop Song, MIDI Reset - both interpreted internally and sent to plugins
for(CHANNELINDEX chn = 0; chn < GetNumChannels(); chn++)
{
playState.Chn[chn].nCutOff = 0x7F;
playState.Chn[chn].nResonance = 0x00;
}
}
ModChannel &chn = playState.Chn[nChn];
if(macro.size() == 4 && macro[0] == 0xF0 && (macro[1] == 0xF0 || macro[1] == 0xF1))
{
// Internal device.
const bool isExtended = (macro[1] == 0xF1);
const uint8 macroCode = macro[2];
const uint8 param = macro[3];
if(macroCode == 0x00 && !isExtended && param < 0x80)
{
// F0.F0.00.xx: Set CutOff
if(!isSmooth)
chn.nCutOff = param;
else
chn.nCutOff = mpt::saturate_round<uint8>(CalculateSmoothParamChange(playState, chn.nCutOff, param));
chn.nRestoreCutoffOnNewNote = 0;
int cutoff = SetupChannelFilter(chn, !chn.dwFlags[CHN_FILTER]);
if(cutoff >= 0 && chn.dwFlags[CHN_ADLIB] && m_opl && !localOnly)
{
// Cutoff doubles as modulator intensity for FM instruments
m_opl->Volume(nChn, static_cast<uint8>(cutoff / 4), true);
}
} else if(macroCode == 0x01 && !isExtended && param < 0x80)
{
// F0.F0.01.xx: Set Resonance
if(!isSmooth)
chn.nResonance = param;
else
chn.nResonance = mpt::saturate_round<uint8>(CalculateSmoothParamChange(playState, chn.nResonance, param));
chn.nRestoreResonanceOnNewNote = 0;
SetupChannelFilter(chn, !chn.dwFlags[CHN_FILTER]);
} else if(macroCode == 0x02 && !isExtended)
{
// F0.F0.02.xx: Set filter mode (high nibble determines filter mode)
if(param < 0x20)
{
chn.nFilterMode = static_cast<FilterMode>(param >> 4);
SetupChannelFilter(chn, !chn.dwFlags[CHN_FILTER]);
}
#ifndef NO_PLUGINS
} else if(macroCode == 0x03 && !isExtended)
{
// F0.F0.03.xx: Set plug dry/wet
PLUGINDEX plug = (plugin != 0) ? plugin : GetBestPlugin(playState, nChn, PrioritiseChannel, EvenIfMuted);
if(plug > 0 && plug <= MAX_MIXPLUGINS && param < 0x80)
{
plug--;
if(IMixPlugin* pPlugin = m_MixPlugins[plug].pMixPlugin; pPlugin)
{
const float newRatio = (127 - param) / 127.0f;
if(localOnly)
playState.m_midiMacroEvaluationResults->pluginDryWetRatio[plug] = newRatio;
else if(!isSmooth)
pPlugin->SetDryRatio(newRatio);
else
pPlugin->SetDryRatio(CalculateSmoothParamChange(playState, m_MixPlugins[plug].fDryRatio, newRatio));
}
}
} else if((macroCode & 0x80) || isExtended)
{
// F0.F0.{80|n}.xx / F0.F1.n.xx: Set VST effect parameter n to xx
PLUGINDEX plug = (plugin != 0) ? plugin : GetBestPlugin(playState, nChn, PrioritiseChannel, EvenIfMuted);
if(plug > 0 && plug <= MAX_MIXPLUGINS && param < 0x80)
{
plug--;
if(IMixPlugin *pPlugin = m_MixPlugins[plug].pMixPlugin; pPlugin)
{
const PlugParamIndex plugParam = isExtended ? (0x80 + macroCode) : (macroCode & 0x7F);
const PlugParamValue value = param / 127.0f;
if(localOnly)
playState.m_midiMacroEvaluationResults->pluginParameter[{plug, plugParam}] = value;
else if(!isSmooth)
pPlugin->SetParameter(plugParam, value);
else
pPlugin->SetParameter(plugParam, CalculateSmoothParamChange(playState, pPlugin->GetParameter(plugParam), value));
}
}
#endif // NO_PLUGINS
}
} else if(!localOnly)
{
#ifndef NO_PLUGINS
// Not an internal device. Pass on to appropriate plugin.
const CHANNELINDEX plugChannel = (nChn < GetNumChannels()) ? nChn + 1 : chn.nMasterChn;
if(plugChannel > 0 && plugChannel <= GetNumChannels()) // XXX do we need this? I guess it might be relevant for previewing notes in the pattern... Or when using this mechanism for volume/panning!
{
PLUGINDEX plug = 0;
if(!chn.dwFlags[CHN_NOFX])
{
plug = (plugin != 0) ? plugin : GetBestPlugin(playState, nChn, PrioritiseChannel, EvenIfMuted);
}
if(plug > 0 && plug <= MAX_MIXPLUGINS)
{
if(IMixPlugin *pPlugin = m_MixPlugins[plug - 1].pMixPlugin; pPlugin != nullptr)
{
if(macro[0] == 0xF0)
{
pPlugin->MidiSysexSend(mpt::byte_cast<mpt::const_byte_span>(macro));
} else
{
size_t len = std::min(static_cast<size_t>(MIDIEvents::GetEventLength(macro[0])), macro.size());
uint32 curData = 0;
memcpy(&curData, macro.data(), len);
pPlugin->MidiSend(curData);
}
}
}
}
#else
MPT_UNREFERENCED_PARAMETER(plugin);
#endif // NO_PLUGINS
}
}
void CSoundFile::SendMIDINote(CHANNELINDEX chn, uint16 note, uint16 volume)
{
#ifndef NO_PLUGINS
auto &channel = m_PlayState.Chn[chn];
const ModInstrument *pIns = channel.pModInstrument;
// instro sends to a midi chan
if (pIns && pIns->HasValidMIDIChannel())
{
PLUGINDEX plug = pIns->nMixPlug;
if(plug > 0 && plug <= MAX_MIXPLUGINS)
{
IMixPlugin *pPlug = m_MixPlugins[plug - 1].pMixPlugin;
if (pPlug != nullptr)
{
pPlug->MidiCommand(*pIns, note, volume, chn);
if(note < NOTE_MIN_SPECIAL)
channel.nLeftVU = channel.nRightVU = 0xFF;
}
}
}
#endif // NO_PLUGINS
}
void CSoundFile::ProcessSampleOffset(ModChannel &chn, CHANNELINDEX nChn, const PlayState &playState) const
{
const ModCommand &m = chn.rowCommand;
uint32 extendedRows = 0;
SmpLength offset = CalculateXParam(playState.m_nPattern, playState.m_nRow, nChn, &extendedRows), highOffset = 0;
if(!extendedRows)
{
// No X-param (normal behaviour)
const bool isPercentageOffset = (m.volcmd == VOLCMD_OFFSET && m.vol == 0);
offset <<= 8;
if(offset)
chn.oldOffset = offset;
else if(m.volcmd != VOLCMD_OFFSET)
offset = chn.oldOffset;
if(!isPercentageOffset)
highOffset = static_cast<SmpLength>(chn.nOldHiOffset) << 16;
}
if(m.volcmd == VOLCMD_OFFSET)
{
if(m.vol == 0)
offset = Util::muldivr_unsigned(chn.nLength, offset, 256u << (8u * std::max(uint32(1), extendedRows))); // o00 + Oxx = Percentage Offset
else if(m.vol <= std::size(ModSample().cues) && chn.pModSample != nullptr)
offset += chn.pModSample->cues[m.vol - 1]; // Offset relative to cue point
chn.oldOffset = offset;
}
SampleOffset(chn, offset + highOffset);
}
void CSoundFile::SampleOffset(ModChannel &chn, SmpLength param) const
{
// ST3 compatibility: Instrument-less note recalls previous note's offset
// Test case: OxxMemory.s3m
if(m_playBehaviour[kST3OffsetWithoutInstrument])
chn.prevNoteOffset = 0;
chn.prevNoteOffset += param;
if(param >= chn.nLoopEnd && (GetType() & (MOD_TYPE_S3M | MOD_TYPE_MTM)) && chn.dwFlags[CHN_LOOP] && chn.nLoopEnd > 0)
{
// Offset wrap-around
// Note that ST3 only does this in GUS mode. SoundBlaster stops the sample entirely instead.
// Test case: OffsetLoopWraparound.s3m
param = (param - chn.nLoopStart) % (chn.nLoopEnd - chn.nLoopStart) + chn.nLoopStart;
}
if(GetType() == MOD_TYPE_MDL && chn.dwFlags[CHN_16BIT])
{
// Digitrakker really uses byte offsets, not sample offsets. WTF!
param /= 2u;
}
if(chn.rowCommand.IsNote() || m_playBehaviour[kApplyOffsetWithoutNote])
{
// IT compatibility: If this note is not mapped to a sample, ignore it.
// Test case: empty_sample_offset.it
if(chn.pModInstrument != nullptr && chn.rowCommand.IsNote())
{
SAMPLEINDEX smp = chn.pModInstrument->Keyboard[chn.rowCommand.note - NOTE_MIN];
if(smp == 0 || smp > GetNumSamples())
return;
}
if(m_SongFlags[SONG_PT_MODE])
{
// ProTracker compatbility: PT1/2-style funky 9xx offset command
// Test case: ptoffset.mod
chn.position.Set(chn.prevNoteOffset);
chn.prevNoteOffset += param;
} else
{
chn.position.Set(param);
}
if (chn.position.GetUInt() >= chn.nLength || (chn.dwFlags[CHN_LOOP] && chn.position.GetUInt() >= chn.nLoopEnd))
{
// Offset beyond sample size
if(m_playBehaviour[kFT2ST3OffsetOutOfRange] || GetType() == MOD_TYPE_MTM)
{
// FT2 Compatibility: Don't play note if offset is beyond sample length
// ST3 Compatibility: Don't play note if offset is beyond sample length (non-looped samples only)
// Test cases: 3xx-no-old-samp.xm, OffsetPastSampleEnd.s3m
chn.dwFlags.set(CHN_FASTVOLRAMP);
chn.nPeriod = 0;
} else if(!(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2 | MOD_TYPE_MOD)))
{
// IT Compatibility: Offset
if(m_playBehaviour[kITOffset])
{
if(m_SongFlags[SONG_ITOLDEFFECTS])
chn.position.Set(chn.nLength); // Old FX: Clip to end of sample
else
chn.position.Set(0); // Reset to beginning of sample
} else
{
chn.position.Set(chn.nLoopStart);
if(m_SongFlags[SONG_ITOLDEFFECTS] && chn.nLength > 4)
{
chn.position.Set(chn.nLength - 2);
}
}
} else if(GetType() == MOD_TYPE_MOD && chn.dwFlags[CHN_LOOP])
{
chn.position.Set(chn.nLoopStart);
}
}
} else if ((param < chn.nLength) && (GetType() & (MOD_TYPE_MTM | MOD_TYPE_DMF | MOD_TYPE_MDL | MOD_TYPE_PLM)))
{
// Some trackers can also call offset effects without notes next to them...
chn.position.Set(param);
}
}
void CSoundFile::ReverseSampleOffset(ModChannel &chn, ModCommand::PARAM param) const
{
if(chn.pModSample != nullptr && chn.pModSample->nLength > 0)
{
chn.dwFlags.set(CHN_PINGPONGFLAG);
chn.dwFlags.reset(CHN_LOOP);
chn.nLength = chn.pModSample->nLength; // If there was a loop, extend sample to whole length.
chn.position.Set((chn.nLength - 1) - std::min(SmpLength(param) << 8, chn.nLength - SmpLength(1)), 0);
}
}
void CSoundFile::DigiBoosterSampleReverse(ModChannel &chn, ModCommand::PARAM param) const
{
if(chn.isFirstTick && chn.pModSample != nullptr && chn.pModSample->nLength > 0)
{
chn.dwFlags.set(CHN_PINGPONGFLAG);
chn.nLength = chn.pModSample->nLength; // If there was a loop, extend sample to whole length.
chn.position.Set(chn.nLength - 1, 0);
chn.dwFlags.set(CHN_LOOP | CHN_PINGPONGLOOP, param > 0);
if(param > 0)
{
chn.nLoopStart = 0;
chn.nLoopEnd = chn.nLength;
// TODO: When the sample starts playing in forward direction again, the loop should be updated to the normal sample loop.
}
}
}
void CSoundFile::HandleDigiSamplePlayDirection(PlayState &state, CHANNELINDEX chn) const
{
// Digi Booster mixes two channels into one Paula channel, and when a note is triggered on one of them it resets the reverse play flag on the other.
if(GetType() == MOD_TYPE_DIGI)
{
state.Chn[chn].dwFlags.reset(CHN_PINGPONGFLAG);
const CHANNELINDEX otherChn = chn ^ 1;
if(otherChn < GetNumChannels())
state.Chn[otherChn].dwFlags.reset(CHN_PINGPONGFLAG);
}
}
void CSoundFile::RetrigNote(CHANNELINDEX nChn, int param, int offset)
{
// Retrig: bit 8 is set if it's the new XM retrig
ModChannel &chn = m_PlayState.Chn[nChn];
int retrigSpeed = param & 0x0F;
uint8 retrigCount = chn.nRetrigCount;
bool doRetrig = false;
// IT compatibility 15. Retrigger
if(m_playBehaviour[kITRetrigger])
{
if(m_PlayState.m_nTickCount == 0 && chn.rowCommand.note)
{
chn.nRetrigCount = param & 0x0F;
} else if(!chn.nRetrigCount || !--chn.nRetrigCount)
{
chn.nRetrigCount = param & 0x0F;
doRetrig = true;
}
} else if(m_playBehaviour[kFT2Retrigger] && (param & 0x100))
{
// Buggy-like-hell FT2 Rxy retrig!
// Test case: retrig.xm
if(m_SongFlags[SONG_FIRSTTICK])
{
// Here are some really stupid things FT2 does on the first tick.
// Test case: RetrigTick0.xm
if(chn.rowCommand.instr > 0 && chn.rowCommand.IsNoteOrEmpty())
retrigCount = 1;
if(chn.rowCommand.volcmd == VOLCMD_VOLUME && chn.rowCommand.vol != 0)
{
// I guess this condition simply checked if the volume byte was != 0 in FT2.
chn.nRetrigCount = retrigCount;
return;
}
}
if(retrigCount >= retrigSpeed)
{
if(!m_SongFlags[SONG_FIRSTTICK] || !chn.rowCommand.IsNote())
{
doRetrig = true;
retrigCount = 0;
}
}
} else
{
// old routines
if (GetType() & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT))
{
if(!retrigSpeed)
retrigSpeed = 1;
if(retrigCount && !(retrigCount % retrigSpeed))
doRetrig = true;
retrigCount++;
} else if(GetType() == MOD_TYPE_MOD)
{
// ProTracker-style retrigger
// Test case: PTRetrigger.mod
const auto tick = m_PlayState.m_nTickCount % m_PlayState.m_nMusicSpeed;
if(!tick && chn.rowCommand.IsNote())
return;
if(retrigSpeed && !(tick % retrigSpeed))
doRetrig = true;
} else if(GetType() == MOD_TYPE_MTM)
{
// In MultiTracker, E9x retriggers the last note at exactly the x-th tick of the row
doRetrig = m_PlayState.m_nTickCount == static_cast<uint32>(param & 0x0F) && retrigSpeed != 0;
} else
{
int realspeed = retrigSpeed;
// FT2 bug: if a retrig (Rxy) occurs together with a volume command, the first retrig interval is increased by one tick
if((param & 0x100) && (chn.rowCommand.volcmd == VOLCMD_VOLUME) && (chn.rowCommand.param & 0xF0))
realspeed++;
if(!m_SongFlags[SONG_FIRSTTICK] || (param & 0x100))
{
if(!realspeed)
realspeed = 1;
if(!(param & 0x100) && m_PlayState.m_nMusicSpeed && !(m_PlayState.m_nTickCount % realspeed))
doRetrig = true;
retrigCount++;
} else if(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2))
retrigCount = 0;
if (retrigCount >= realspeed)
{
if(m_PlayState.m_nTickCount || ((param & 0x100) && !chn.rowCommand.note))
doRetrig = true;
}
if(m_playBehaviour[kFT2Retrigger] && param == 0)
{
// E90 = Retrig instantly, and only once
doRetrig = (m_PlayState.m_nTickCount == 0);
}
}
}
// IT compatibility: If a sample is shorter than the retrig time (i.e. it stops before the retrig counter hits zero), it is not retriggered.
// Test case: retrig-short.it
if(chn.nLength == 0 && m_playBehaviour[kITShortSampleRetrig] && !chn.HasMIDIOutput())
return;
// ST3 compatibility: No retrig after Note Cut
// Test case: RetrigAfterNoteCut.s3m
if(m_playBehaviour[kST3RetrigAfterNoteCut] && !chn.nFadeOutVol)
return;
if(doRetrig)
{
uint32 dv = (param >> 4) & 0x0F;
int vol = chn.nVolume;
if(dv)
{
// FT2 compatibility: Retrig + volume will not change volume of retrigged notes
if(!m_playBehaviour[kFT2Retrigger] || !(chn.rowCommand.volcmd == VOLCMD_VOLUME))
{
if(retrigTable1[dv])
vol = (vol * retrigTable1[dv]) / 16;
else
vol += ((int)retrigTable2[dv]) * 4;
}
Limit(vol, 0, 256);
chn.dwFlags.set(CHN_FASTVOLRAMP);
}
uint32 note = chn.nNewNote;
int32 oldPeriod = chn.nPeriod;
// ST3 doesn't retrigger OPL notes
// Test case: RetrigSlide.s3m
const bool oplRealRetrig = chn.dwFlags[CHN_ADLIB] && m_playBehaviour[kOPLRealRetrig];
if(note >= NOTE_MIN && note <= NOTE_MAX && chn.nLength && (GetType() != MOD_TYPE_S3M || oplRealRetrig))
CheckNNA(nChn, 0, note, true);
bool resetEnv = false;
if(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2))
{
if(chn.rowCommand.instr && param < 0x100)
{
InstrumentChange(chn, chn.rowCommand.instr, false, false);
resetEnv = true;
}
if(param < 0x100)
resetEnv = true;
}
const bool fading = chn.dwFlags[CHN_NOTEFADE];
const auto oldPrevNoteOffset = chn.prevNoteOffset;
chn.prevNoteOffset = 0; // Retriggered notes should not use previous offset (test case: OxxMemoryWithRetrig.s3m)
// IT compatibility: Really weird combination of envelopes and retrigger (see Storlek's q.it testcase)
// Test cases: retrig.it, RetrigSlide.s3m
const bool itS3Mstyle = m_playBehaviour[kITRetrigger] || (GetType() == MOD_TYPE_S3M && chn.nLength && !oplRealRetrig);
NoteChange(chn, note, itS3Mstyle, resetEnv, false, nChn);
if(!chn.rowCommand.instr)
chn.prevNoteOffset = oldPrevNoteOffset;
// XM compatibility: Prevent NoteChange from resetting the fade flag in case an instrument number + note-off is present.
// Test case: RetrigFade.xm
if(fading && GetType() == MOD_TYPE_XM)
chn.dwFlags.set(CHN_NOTEFADE);
chn.nVolume = vol;
if(m_nInstruments)
{
chn.rowCommand.note = static_cast<ModCommand::NOTE>(note); // No retrig without note...
#ifndef NO_PLUGINS
ProcessMidiOut(nChn); //Send retrig to Midi
#endif // NO_PLUGINS
}
if((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && chn.rowCommand.note == NOTE_NONE && oldPeriod != 0)
chn.nPeriod = oldPeriod;
if(!(GetType() & (MOD_TYPE_S3M | MOD_TYPE_IT | MOD_TYPE_MPT)))
retrigCount = 0;
// IT compatibility: see previous IT compatibility comment =)
if(itS3Mstyle)
chn.position.Set(0);
offset--;
if(chn.pModSample != nullptr && offset >= 0 && offset <= static_cast<int>(std::size(chn.pModSample->cues)))
{
if(offset == 0)
offset = chn.oldOffset;
else
offset = chn.oldOffset = chn.pModSample->cues[offset - 1];
SampleOffset(chn, offset);
}
}
// buggy-like-hell FT2 Rxy retrig!
if(m_playBehaviour[kFT2Retrigger] && (param & 0x100))
retrigCount++;
// Now we can also store the retrig value for IT...
if(!m_playBehaviour[kITRetrigger])
chn.nRetrigCount = retrigCount;
}
// Execute a frequency slide on given channel.
// Positive amounts increase the frequency, negative amounts decrease it.
// The period or frequency that is read and written is in the period variable, chn.nPeriod is not touched.
void CSoundFile::DoFreqSlide(ModChannel &chn, int32 &period, int32 amount, bool isTonePorta) const
{
if(!period || !amount)
return;
MPT_ASSERT(!chn.HasCustomTuning());
if(GetType() == MOD_TYPE_669)
{
// Like other oldskool trackers, Composer 669 doesn't have linear slides...
// But the slides are done in Hertz rather than periods, meaning that they
// are more effective in the lower notes (rather than the higher notes).
period += amount * 20;
} else if(GetType() == MOD_TYPE_FAR)
{
period += (amount * 36318 / 1024);
} else if(m_SongFlags[SONG_LINEARSLIDES] && GetType() != MOD_TYPE_XM)
{
// IT Linear slides
const auto oldPeriod = period;
uint32 n = std::abs(amount);
LimitMax(n, 255u * 4u);
// Note: IT ignores the lower 2 bits when abs(mount) > 16 (it either uses the fine *or* the regular table, not both)
// This means that vibratos are slightly less accurate in this range than they could be.
// Other code paths will *either* have an amount that's a multiple of 4 *or* it's less than 16.
if(amount > 0)
{
if(n < 16)
period = Util::muldivr(period, GetFineLinearSlideUpTable(this, n), 65536);
else
period = Util::muldivr(period, GetLinearSlideUpTable(this, n / 4u), 65536);
} else
{
if(n < 16)
period = Util::muldivr(period, GetFineLinearSlideDownTable(this, n), 65536);
else
period = Util::muldivr(period, GetLinearSlideDownTable(this, n / 4u), 65536);
}
if(period == oldPeriod)
{
const bool incPeriod = m_playBehaviour[kPeriodsAreHertz] == (amount > 0);
if(incPeriod && period < Util::MaxValueOfType(period))
period++;
else if(!incPeriod && period > 1)
period--;
}
} else if(!m_SongFlags[SONG_LINEARSLIDES] && m_playBehaviour[kPeriodsAreHertz])
{
// IT Amiga slides
if(amount < 0)
{
// Go down
period = mpt::saturate_cast<int32>(Util::mul32to64_unsigned(1712 * 8363, period) / (Util::mul32to64_unsigned(period, -amount) + 1712 * 8363));
} else if(amount > 0)
{
// Go up
const auto periodDiv = 1712 * 8363 - Util::mul32to64(period, amount);
if(periodDiv <= 0)
{
if(isTonePorta)
{
period = int32_max;
return;
} else
{
period = 0;
chn.nFadeOutVol = 0;
chn.dwFlags.set(CHN_NOTEFADE | CHN_FASTVOLRAMP);
}
return;
}
period = mpt::saturate_cast<int32>(Util::mul32to64_unsigned(1712 * 8363, period) / periodDiv);
}
} else
{
period -= amount;
}
if(period < 1)
{
period = 1;
if(GetType() == MOD_TYPE_S3M && !isTonePorta)
{
chn.nFadeOutVol = 0;
chn.dwFlags.set(CHN_NOTEFADE | CHN_FASTVOLRAMP);
}
}
}
void CSoundFile::NoteCut(CHANNELINDEX nChn, uint32 nTick, bool cutSample)
{
if (m_PlayState.m_nTickCount == nTick)
{
ModChannel &chn = m_PlayState.Chn[nChn];
if(cutSample)
{
chn.increment.Set(0);
chn.nFadeOutVol = 0;
chn.dwFlags.set(CHN_NOTEFADE);
} else
{
chn.nVolume = 0;
}
chn.dwFlags.set(CHN_FASTVOLRAMP);
// instro sends to a midi chan
SendMIDINote(nChn, /*chn.nNote+*/NOTE_MAX_SPECIAL, 0);
if(chn.dwFlags[CHN_ADLIB] && m_opl)
{
m_opl->NoteCut(nChn, false);
}
}
}
void CSoundFile::KeyOff(ModChannel &chn) const
{
const bool keyIsOn = !chn.dwFlags[CHN_KEYOFF];
chn.dwFlags.set(CHN_KEYOFF);
if(chn.pModInstrument != nullptr && !chn.VolEnv.flags[ENV_ENABLED])
{
chn.dwFlags.set(CHN_NOTEFADE);
}
if (!chn.nLength) return;
if (chn.dwFlags[CHN_SUSTAINLOOP] && chn.pModSample && keyIsOn)
{
const ModSample *pSmp = chn.pModSample;
if(pSmp->uFlags[CHN_LOOP])
{
if (pSmp->uFlags[CHN_PINGPONGLOOP])
chn.dwFlags.set(CHN_PINGPONGLOOP);
else
chn.dwFlags.reset(CHN_PINGPONGLOOP | CHN_PINGPONGFLAG);
chn.dwFlags.set(CHN_LOOP);
chn.nLength = pSmp->nLength;
chn.nLoopStart = pSmp->nLoopStart;
chn.nLoopEnd = pSmp->nLoopEnd;
if (chn.nLength > chn.nLoopEnd) chn.nLength = chn.nLoopEnd;
if(chn.position.GetUInt() > chn.nLength)
{
// Test case: SusAfterLoop.it
chn.position.Set(chn.nLoopStart + ((chn.position.GetInt() - chn.nLoopStart) % (chn.nLoopEnd - chn.nLoopStart)));
}
} else
{
chn.dwFlags.reset(CHN_LOOP | CHN_PINGPONGLOOP | CHN_PINGPONGFLAG);
chn.nLength = pSmp->nLength;
}
}
if (chn.pModInstrument)
{
const ModInstrument *pIns = chn.pModInstrument;
if((pIns->VolEnv.dwFlags[ENV_LOOP] || (GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2 | MOD_TYPE_MDL))) && pIns->nFadeOut != 0)
{
chn.dwFlags.set(CHN_NOTEFADE);
}
if (pIns->VolEnv.nReleaseNode != ENV_RELEASE_NODE_UNSET && chn.VolEnv.nEnvValueAtReleaseJump == NOT_YET_RELEASED)
{
chn.VolEnv.nEnvValueAtReleaseJump = mpt::saturate_cast<int16>(pIns->VolEnv.GetValueFromPosition(chn.VolEnv.nEnvPosition, 256));
chn.VolEnv.nEnvPosition = pIns->VolEnv[pIns->VolEnv.nReleaseNode].tick;
}
}
}
//////////////////////////////////////////////////////////
// CSoundFile: Global Effects
void CSoundFile::SetSpeed(PlayState &playState, uint32 param) const
{
#ifdef MODPLUG_TRACKER
// FT2 appears to be decrementing the tick count before checking for zero,
// so it effectively counts down 65536 ticks with speed = 0 (song speed is a 16-bit variable in FT2)
if(GetType() == MOD_TYPE_XM && !param)
{
playState.m_nMusicSpeed = uint16_max;
}
#endif // MODPLUG_TRACKER
if(param > 0) playState.m_nMusicSpeed = param;
if(GetType() == MOD_TYPE_STM && param > 0)
{
playState.m_nMusicSpeed = std::max(param >> 4, uint32(1));
playState.m_nMusicTempo = ConvertST2Tempo(static_cast<uint8>(param));
}
}
// Convert a ST2 tempo byte to classic tempo and speed combination
TEMPO CSoundFile::ConvertST2Tempo(uint8 tempo)
{
static constexpr uint8 ST2TempoFactor[] = { 140, 50, 25, 15, 10, 7, 6, 4, 3, 3, 2, 2, 2, 2, 1, 1 };
static constexpr uint32 st2MixingRate = 23863; // Highest possible setting in ST2
// This underflows at tempo 06...0F, and the resulting tick lengths depend on the mixing rate.
// Note: ST2.3 uses the constant 50 below, earlier versions use 49 but they also play samples at a different speed.
int32 samplesPerTick = st2MixingRate / (50 - ((ST2TempoFactor[tempo >> 4u] * (tempo & 0x0F)) >> 4u));
if(samplesPerTick <= 0)
samplesPerTick += 65536;
return TEMPO().SetRaw(Util::muldivrfloor(st2MixingRate, 5 * TEMPO::fractFact, samplesPerTick * 2));
}
void CSoundFile::SetTempo(TEMPO param, bool setFromUI)
{
const CModSpecifications &specs = GetModSpecifications();
// Anything lower than the minimum tempo is considered to be a tempo slide
const TEMPO minTempo = (GetType() & (MOD_TYPE_MDL | MOD_TYPE_MED | MOD_TYPE_MOD)) ? TEMPO(1, 0) : TEMPO(32, 0);
if(setFromUI)
{
// Set tempo from UI - ignore slide commands and such.
m_PlayState.m_nMusicTempo = Clamp(param, specs.GetTempoMin(), specs.GetTempoMax());
} else if(param >= minTempo && m_SongFlags[SONG_FIRSTTICK] == !m_playBehaviour[kMODTempoOnSecondTick])
{
// ProTracker sets the tempo after the first tick.
// Note: The case of one tick per row is handled in ProcessRow() instead.
// Test case: TempoChange.mod
m_PlayState.m_nMusicTempo = std::min(param, specs.GetTempoMax());
} else if(param < minTempo && !m_SongFlags[SONG_FIRSTTICK])
{
// Tempo Slide
TEMPO tempDiff(param.GetInt() & 0x0F, 0);
if((param.GetInt() & 0xF0) == 0x10)
m_PlayState.m_nMusicTempo += tempDiff;
else
m_PlayState.m_nMusicTempo -= tempDiff;
TEMPO tempoMin = specs.GetTempoMin(), tempoMax = specs.GetTempoMax();
if(m_playBehaviour[kTempoClamp]) // clamp tempo correctly in compatible mode
{
tempoMax.Set(255);
}
Limit(m_PlayState.m_nMusicTempo, tempoMin, tempoMax);
}
}
void CSoundFile::PatternLoop(PlayState &state, ModChannel &chn, ModCommand::PARAM param) const
{
if(m_playBehaviour[kST3NoMutedChannels] && chn.dwFlags[CHN_MUTE | CHN_SYNCMUTE])
return; // not even effects are processed on muted S3M channels
if(!param)
{
// Loop Start
chn.nPatternLoop = state.m_nRow;
return;
}
// Loop Repeat
if(chn.nPatternLoopCount)
{
// There's a loop left
chn.nPatternLoopCount--;
if(!chn.nPatternLoopCount)
{
// IT compatibility 10. Pattern loops (+ same fix for S3M files)
// When finishing a pattern loop, the next loop without a dedicated SB0 starts on the first row after the previous loop.
if(m_playBehaviour[kITPatternLoopTargetReset] || (GetType() == MOD_TYPE_S3M))
chn.nPatternLoop = state.m_nRow + 1;
return;
}
} else
{
// First time we get into the loop => Set loop count.
// IT compatibility 10. Pattern loops (+ same fix for XM / MOD / S3M files)
if(!m_playBehaviour[kITFT2PatternLoop] && !(GetType() & (MOD_TYPE_MOD | MOD_TYPE_S3M)))
{
auto p = std::cbegin(state.Chn);
for(CHANNELINDEX i = 0; i < GetNumChannels(); i++, p++)
{
// Loop on other channel
if(p != &chn && p->nPatternLoopCount)
return;
}
}
chn.nPatternLoopCount = param;
}
state.m_nextPatStartRow = chn.nPatternLoop; // Nasty FT2 E60 bug emulation!
const auto loopTarget = chn.nPatternLoop;
if(loopTarget != ROWINDEX_INVALID)
{
// FT2 compatibility: E6x overwrites jump targets of Dxx effects that are located left of the E6x effect.
// Test cases: PatLoop-Jumps.xm, PatLoop-Various.xm
if(state.m_breakRow != ROWINDEX_INVALID && m_playBehaviour[kFT2PatternLoopWithJumps])
state.m_breakRow = loopTarget;
state.m_patLoopRow = loopTarget;
// IT compatibility: SBx is prioritized over Position Jump (Bxx) effects that are located left of the SBx effect.
// Test case: sbx-priority.it, LoopBreak.it
if(m_playBehaviour[kITPatternLoopWithJumps])
state.m_posJump = ORDERINDEX_INVALID;
}
if(GetType() == MOD_TYPE_S3M)
{
// ST3 doesn't have per-channel pattern loop memory, so spam all changes to other channels as well.
for(CHANNELINDEX i = 0; i < GetNumChannels(); i++)
{
state.Chn[i].nPatternLoop = chn.nPatternLoop;
state.Chn[i].nPatternLoopCount = chn.nPatternLoopCount;
}
}
}
void CSoundFile::GlobalVolSlide(ModCommand::PARAM param, uint8 &nOldGlobalVolSlide)
{
int32 nGlbSlide = 0;
if (param) nOldGlobalVolSlide = param; else param = nOldGlobalVolSlide;
if((GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2)))
{
// XM nibble priority
if((param & 0xF0) != 0)
{
param &= 0xF0;
} else
{
param &= 0x0F;
}
}
if (((param & 0x0F) == 0x0F) && (param & 0xF0))
{
if(m_SongFlags[SONG_FIRSTTICK]) nGlbSlide = (param >> 4) * 2;
} else
if (((param & 0xF0) == 0xF0) && (param & 0x0F))
{
if(m_SongFlags[SONG_FIRSTTICK]) nGlbSlide = - (int)((param & 0x0F) * 2);
} else
{
if(!m_SongFlags[SONG_FIRSTTICK])
{
if (param & 0xF0)
{
// IT compatibility: Ignore slide commands with both nibbles set.
if(!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_IMF | MOD_TYPE_J2B | MOD_TYPE_MID | MOD_TYPE_AMS | MOD_TYPE_DBM)) || (param & 0x0F) == 0)
nGlbSlide = (int)((param & 0xF0) >> 4) * 2;
} else
{
nGlbSlide = -(int)((param & 0x0F) * 2);
}
}
}
if (nGlbSlide)
{
if(!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT | MOD_TYPE_IMF | MOD_TYPE_J2B | MOD_TYPE_MID | MOD_TYPE_AMS | MOD_TYPE_DBM))) nGlbSlide *= 2;
nGlbSlide += m_PlayState.m_nGlobalVolume;
Limit(nGlbSlide, 0, 256);
m_PlayState.m_nGlobalVolume = nGlbSlide;
}
}
//////////////////////////////////////////////////////
// Note/Period/Frequency functions
// Find lowest note which has same or lower period as a given period (i.e. the note has the same or higher frequency)
uint32 CSoundFile::GetNoteFromPeriod(uint32 period, int32 nFineTune, uint32 nC5Speed) const
{
if(!period) return 0;
if(m_playBehaviour[kFT2Periods])
{
// FT2's "RelocateTon" function actually rounds up and down, while GetNoteFromPeriod normally just truncates.
nFineTune += 64;
}
// This essentially implements std::lower_bound, with the difference that we don't need an iterable container.
uint32 minNote = NOTE_MIN, maxNote = NOTE_MAX, count = maxNote - minNote + 1;
const bool periodIsFreq = PeriodsAreFrequencies();
while(count > 0)
{
const uint32 step = count / 2, midNote = minNote + step;
uint32 n = GetPeriodFromNote(midNote, nFineTune, nC5Speed);
if((n > period && !periodIsFreq) || (n < period && periodIsFreq) || !n)
{
minNote = midNote + 1;
count -= step + 1;
} else
{
count = step;
}
}
return minNote;
}
uint32 CSoundFile::GetPeriodFromNote(uint32 note, int32 nFineTune, uint32 nC5Speed) const
{
if (note == NOTE_NONE || (note >= NOTE_MIN_SPECIAL)) return 0;
note -= NOTE_MIN;
if(!UseFinetuneAndTranspose())
{
if(GetType() & (MOD_TYPE_MDL | MOD_TYPE_DTM))
{
// MDL uses non-linear slides, but their effectiveness does not depend on the middle-C frequency.
return (FreqS3MTable[note % 12u] << 4) >> (note / 12);
}
if(!nC5Speed)
nC5Speed = 8363;
if(PeriodsAreFrequencies())
{
// Compute everything in Hertz rather than periods.
uint32 freq = Util::muldiv_unsigned(nC5Speed, LinearSlideUpTable[(note % 12u) * 16u] << (note / 12u), 65536 << 5);
LimitMax(freq, static_cast<uint32>(int32_max));
return freq;
} else if(m_SongFlags[SONG_LINEARSLIDES])
{
return (FreqS3MTable[note % 12u] << 5) >> (note / 12);
} else
{
LimitMax(nC5Speed, uint32_max >> (note / 12u));
//(a*b)/c
return Util::muldiv_unsigned(8363, (FreqS3MTable[note % 12u] << 5), nC5Speed << (note / 12u));
//8363 * freq[note%12] / nC5Speed * 2^(5-note/12)
}
} else if(GetType() & (MOD_TYPE_XM | MOD_TYPE_MTM))
{
if (note < 12) note = 12;
note -= 12;
if(GetType() == MOD_TYPE_MTM)
{
nFineTune *= 16;
} else if(m_playBehaviour[kFT2FinetunePrecision])
{
// FT2 Compatibility: The lower three bits of the finetune are truncated.
// Test case: Finetune-Precision.xm
nFineTune &= ~7;
}
if(m_SongFlags[SONG_LINEARSLIDES])
{
int l = ((NOTE_MAX - note) << 6) - (nFineTune / 2);
if (l < 1) l = 1;
return static_cast<uint32>(l);
} else
{
int finetune = nFineTune;
uint32 rnote = (note % 12) << 3;
uint32 roct = note / 12;
int rfine = finetune / 16;
int i = rnote + rfine + 8;
Limit(i , 0, 103);
uint32 per1 = XMPeriodTable[i];
if(finetune < 0)
{
rfine--;
finetune = -finetune;
} else rfine++;
i = rnote+rfine+8;
if (i < 0) i = 0;
if (i >= 104) i = 103;
uint32 per2 = XMPeriodTable[i];
rfine = finetune & 0x0F;
per1 *= 16-rfine;
per2 *= rfine;
return ((per1 + per2) << 1) >> roct;
}
} else
{
nFineTune = XM2MODFineTune(nFineTune);
if ((nFineTune) || (note < 24) || (note >= 24 + std::size(ProTrackerPeriodTable)))
return (ProTrackerTunedPeriods[nFineTune * 12u + note % 12u] << 5) >> (note / 12u);
else
return (ProTrackerPeriodTable[note - 24] << 2);
}
}
// Converts period value to sample frequency. Return value is fixed point, with FREQ_FRACBITS fractional bits.
uint32 CSoundFile::GetFreqFromPeriod(uint32 period, uint32 c5speed, int32 nPeriodFrac) const
{
if (!period) return 0;
if (GetType() & (MOD_TYPE_XM | MOD_TYPE_MTM))
{
if(m_playBehaviour[kFT2Periods])
{
// FT2 compatibility: Period is a 16-bit value in FT2, and it overflows happily.
// Test case: FreqWraparound.xm
period &= 0xFFFF;
}
if(m_SongFlags[SONG_LINEARSLIDES])
{
uint32 octave;
if(m_playBehaviour[kFT2Periods])
{
// Under normal circumstances, this calculation returns the same values as the non-compatible one.
// However, once the 12 octaves are exceeded (through portamento slides), the octave shift goes
// crazy in FT2, meaning that the frequency wraps around randomly...
// The entries in FT2's conversion table are four times as big, hence we have to do an additional shift by two bits.
// Test case: FreqWraparound.xm
// 12 octaves * (12 * 64) LUT entries = 9216, add 767 for rounding
uint32 div = ((9216u + 767u - period) / 768);
octave = ((14 - div) & 0x1F);
} else
{
octave = (period / 768) + 2;
}
return (XMLinearTable[period % 768] << (FREQ_FRACBITS + 2)) >> octave;
} else
{
if(!period) period = 1;
return ((8363 * 1712L) << FREQ_FRACBITS) / period;
}
} else if(UseFinetuneAndTranspose())
{
return ((3546895L * 4) << FREQ_FRACBITS) / period;
} else if(GetType() == MOD_TYPE_669)
{
// We only really use c5speed for the finetune pattern command. All samples in 669 files have the same middle-C speed (imported as 8363 Hz).
return (period + c5speed - 8363) << FREQ_FRACBITS;
} else if(GetType() & (MOD_TYPE_MDL | MOD_TYPE_DTM))
{
LimitMax(period, Util::MaxValueOfType(period) >> 8);
if (!c5speed) c5speed = 8363;
return Util::muldiv_unsigned(c5speed, (1712L << 7) << FREQ_FRACBITS, (period << 8) + nPeriodFrac);
} else
{
LimitMax(period, Util::MaxValueOfType(period) >> 8);
if(PeriodsAreFrequencies())
{
// Input is already a frequency in Hertz, not a period.
static_assert(FREQ_FRACBITS <= 8, "Check this shift operator");
return uint32(((uint64(period) << 8) + nPeriodFrac) >> (8 - FREQ_FRACBITS));
} else if(m_SongFlags[SONG_LINEARSLIDES])
{
if(!c5speed)
c5speed = 8363;
return Util::muldiv_unsigned(c5speed, (1712L << 8) << FREQ_FRACBITS, (period << 8) + nPeriodFrac);
} else
{
return Util::muldiv_unsigned(8363, (1712L << 8) << FREQ_FRACBITS, (period << 8) + nPeriodFrac);
}
}
}
PLUGINDEX CSoundFile::GetBestPlugin(const PlayState &playState, CHANNELINDEX nChn, PluginPriority priority, PluginMutePriority respectMutes) const
{
if (nChn >= MAX_CHANNELS) //Check valid channel number
{
return 0;
}
//Define search source order
PLUGINDEX plugin = 0;
switch (priority)
{
case ChannelOnly:
plugin = GetChannelPlugin(playState, nChn, respectMutes);
break;
case InstrumentOnly:
plugin = GetActiveInstrumentPlugin(playState.Chn[nChn], respectMutes);
break;
case PrioritiseInstrument:
plugin = GetActiveInstrumentPlugin(playState.Chn[nChn], respectMutes);
if(!plugin || plugin > MAX_MIXPLUGINS)
{
plugin = GetChannelPlugin(playState, nChn, respectMutes);
}
break;
case PrioritiseChannel:
plugin = GetChannelPlugin(playState, nChn, respectMutes);
if(!plugin || plugin > MAX_MIXPLUGINS)
{
plugin = GetActiveInstrumentPlugin(playState.Chn[nChn], respectMutes);
}
break;
}
return plugin; // 0 Means no plugin found.
}
PLUGINDEX CSoundFile::GetChannelPlugin(const PlayState &playState, CHANNELINDEX nChn, PluginMutePriority respectMutes) const
{
const ModChannel &channel = playState.Chn[nChn];
PLUGINDEX plugin;
if((respectMutes == RespectMutes && channel.dwFlags[CHN_MUTE | CHN_SYNCMUTE]) || channel.dwFlags[CHN_NOFX])
{
plugin = 0;
} else
{
// If it looks like this is an NNA channel, we need to find the master channel.
// This ensures we pick up the right ChnSettings.
if(channel.nMasterChn > 0)
{
nChn = channel.nMasterChn - 1;
}
if(nChn < MAX_BASECHANNELS)
{
plugin = ChnSettings[nChn].nMixPlugin;
} else
{
plugin = 0;
}
}
return plugin;
}
PLUGINDEX CSoundFile::GetActiveInstrumentPlugin(const ModChannel &chn, PluginMutePriority respectMutes)
{
// Unlike channel settings, pModInstrument is copied from the original chan to the NNA chan,
// so we don't need to worry about finding the master chan.
PLUGINDEX plug = 0;
if(chn.pModInstrument != nullptr)
{
// TODO this looks fishy. Shouldn't it check the mute status of the instrument itself?!
if(respectMutes == RespectMutes && chn.pModSample && chn.pModSample->uFlags[CHN_MUTE])
{
plug = 0;
} else
{
plug = chn.pModInstrument->nMixPlug;
}
}
return plug;
}
// Retrieve the plugin that is associated with the channel's current instrument.
// No plugin is returned if the channel is muted or if the instrument doesn't have a MIDI channel set up,
// As this is meant to be used with instrument plugins.
IMixPlugin *CSoundFile::GetChannelInstrumentPlugin(const ModChannel &chn) const
{
#ifndef NO_PLUGINS
if(chn.dwFlags[CHN_MUTE | CHN_SYNCMUTE])
{
// Don't process portamento on muted channels. Note that this might have a side-effect
// on other channels which trigger notes on the same MIDI channel of the same plugin,
// as those won't be pitch-bent anymore.
return nullptr;
}
if(chn.HasMIDIOutput())
{
const ModInstrument *pIns = chn.pModInstrument;
// Instrument sends to a MIDI channel
if(pIns->nMixPlug != 0 && pIns->nMixPlug <= MAX_MIXPLUGINS)
{
return m_MixPlugins[pIns->nMixPlug - 1].pMixPlugin;
}
}
#else
MPT_UNREFERENCED_PARAMETER(chn);
#endif // NO_PLUGINS
return nullptr;
}
#ifdef MODPLUG_TRACKER
void CSoundFile::HandlePatternTransitionEvents()
{
// MPT sequence override
if(m_PlayState.m_nSeqOverride != ORDERINDEX_INVALID && m_PlayState.m_nSeqOverride < Order().size())
{
if(m_SongFlags[SONG_PATTERNLOOP])
{
m_PlayState.m_nPattern = Order()[m_PlayState.m_nSeqOverride];
}
m_PlayState.m_nCurrentOrder = m_PlayState.m_nSeqOverride;
m_PlayState.m_nSeqOverride = ORDERINDEX_INVALID;
}
// Channel mutes
for (CHANNELINDEX chan = 0; chan < GetNumChannels(); chan++)
{
if (m_bChannelMuteTogglePending[chan])
{
if(GetpModDoc())
{
GetpModDoc()->MuteChannel(chan, !GetpModDoc()->IsChannelMuted(chan));
}
m_bChannelMuteTogglePending[chan] = false;
}
}
}
#endif // MODPLUG_TRACKER
// Update time signatures (global or pattern-specific). Don't forget to call this when changing the RPB/RPM settings anywhere!
void CSoundFile::UpdateTimeSignature()
{
if(!Patterns.IsValidIndex(m_PlayState.m_nPattern) || !Patterns[m_PlayState.m_nPattern].GetOverrideSignature())
{
m_PlayState.m_nCurrentRowsPerBeat = m_nDefaultRowsPerBeat;
m_PlayState.m_nCurrentRowsPerMeasure = m_nDefaultRowsPerMeasure;
} else
{
m_PlayState.m_nCurrentRowsPerBeat = Patterns[m_PlayState.m_nPattern].GetRowsPerBeat();
m_PlayState.m_nCurrentRowsPerMeasure = Patterns[m_PlayState.m_nPattern].GetRowsPerMeasure();
}
}
void CSoundFile::PortamentoMPT(ModChannel &chn, int param)
{
//Behavior: Modifies portamento by param-steps on every tick.
//Note that step meaning depends on tuning.
chn.m_PortamentoFineSteps += param;
chn.m_CalculateFreq = true;
}
void CSoundFile::PortamentoFineMPT(ModChannel &chn, int param)
{
//Behavior: Divides portamento change between ticks/row. For example
//if Ticks/row == 6, and param == +-6, portamento goes up/down by one tuning-dependent
//fine step every tick.
if(m_PlayState.m_nTickCount == 0)
chn.nOldFinePortaUpDown = 0;
const int tickParam = static_cast<int>((m_PlayState.m_nTickCount + 1.0) * param / m_PlayState.m_nMusicSpeed);
chn.m_PortamentoFineSteps += (param >= 0) ? tickParam - chn.nOldFinePortaUpDown : tickParam + chn.nOldFinePortaUpDown;
if(m_PlayState.m_nTickCount + 1 == m_PlayState.m_nMusicSpeed)
chn.nOldFinePortaUpDown = static_cast<int8>(std::abs(param));
else
chn.nOldFinePortaUpDown = static_cast<int8>(std::abs(tickParam));
chn.m_CalculateFreq = true;
}
void CSoundFile::PortamentoExtraFineMPT(ModChannel &chn, int param)
{
// This kinda behaves like regular fine portamento.
// It changes the pitch by n finetune steps on the first tick.
if(chn.isFirstTick)
{
chn.m_PortamentoFineSteps += param;
chn.m_CalculateFreq = true;
}
}
OPENMPT_NAMESPACE_END
Reference in a new issue View git blame Copy permalink