/*
* Sndmix.cpp
* -----------
* Purpose: Pattern playback, effect processing
* Notes : (currently none)
* 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 "MixerLoops.h"
#include "MIDIEvents.h"
#include "Tables.h"
#ifdef MODPLUG_TRACKER
#include "../mptrack/TrackerSettings.h"
#endif // MODPLUG_TRACKER
#ifndef NO_PLUGINS
#include "plugins/PlugInterface.h"
#endif // NO_PLUGINS
#include "OPL.h"
OPENMPT_NAMESPACE_BEGIN
// Log tables for pre-amp
// Pre-amp (or more precisely: Pre-attenuation) depends on the number of channels,
// Which this table takes care of.
static constexpr uint8 PreAmpTable[16] =
{
0x60, 0x60, 0x60, 0x70, // 0-7
0x80, 0x88, 0x90, 0x98, // 8-15
0xA0, 0xA4, 0xA8, 0xAC, // 16-23
0xB0, 0xB4, 0xB8, 0xBC, // 24-31
};
#ifndef NO_AGC
static constexpr uint8 PreAmpAGCTable[16] =
{
0x60, 0x60, 0x60, 0x64,
0x68, 0x70, 0x78, 0x80,
0x84, 0x88, 0x8C, 0x90,
0x92, 0x94, 0x96, 0x98,
};
#endif
void CSoundFile::SetMixerSettings(const MixerSettings &mixersettings)
{
SetPreAmp(mixersettings.m_nPreAmp); // adjust agc
bool reset = false;
if(
(mixersettings.gdwMixingFreq != m_MixerSettings.gdwMixingFreq)
||
(mixersettings.gnChannels != m_MixerSettings.gnChannels)
||
(mixersettings.MixerFlags != m_MixerSettings.MixerFlags))
reset = true;
m_MixerSettings = mixersettings;
InitPlayer(reset);
}
void CSoundFile::SetResamplerSettings(const CResamplerSettings &resamplersettings)
{
m_Resampler.m_Settings = resamplersettings;
m_Resampler.UpdateTables();
InitAmigaResampler();
}
void CSoundFile::InitPlayer(bool bReset)
{
if(bReset)
{
ResetMixStat();
m_dryLOfsVol = m_dryROfsVol = 0;
m_surroundLOfsVol = m_surroundROfsVol = 0;
InitAmigaResampler();
}
m_Resampler.UpdateTables();
#ifndef NO_REVERB
m_Reverb.Initialize(bReset, m_RvbROfsVol, m_RvbLOfsVol, m_MixerSettings.gdwMixingFreq);
#endif
#ifndef NO_DSP
m_Surround.Initialize(bReset, m_MixerSettings.gdwMixingFreq);
#endif
#ifndef NO_DSP
m_MegaBass.Initialize(bReset, m_MixerSettings.gdwMixingFreq);
#endif
#ifndef NO_EQ
m_EQ.Initialize(bReset, m_MixerSettings.gdwMixingFreq);
#endif
#ifndef NO_AGC
m_AGC.Initialize(bReset, m_MixerSettings.gdwMixingFreq);
#endif
#ifndef NO_DSP
m_BitCrush.Initialize(bReset, m_MixerSettings.gdwMixingFreq);
#endif
if(m_opl)
{
m_opl->Initialize(m_MixerSettings.gdwMixingFreq);
}
}
bool CSoundFile::FadeSong(uint32 msec)
{
samplecount_t nsamples = Util::muldiv(msec, m_MixerSettings.gdwMixingFreq, 1000);
if (nsamples <= 0) return false;
if (nsamples > 0x100000) nsamples = 0x100000;
m_PlayState.m_nBufferCount = nsamples;
int32 nRampLength = static_cast<int32>(m_PlayState.m_nBufferCount);
// Ramp everything down
for (uint32 noff=0; noff < m_nMixChannels; noff++)
{
ModChannel &pramp = m_PlayState.Chn[m_PlayState.ChnMix[noff]];
pramp.newRightVol = pramp.newLeftVol = 0;
pramp.leftRamp = -pramp.leftVol * (1 << VOLUMERAMPPRECISION) / nRampLength;
pramp.rightRamp = -pramp.rightVol * (1 << VOLUMERAMPPRECISION) / nRampLength;
pramp.rampLeftVol = pramp.leftVol * (1 << VOLUMERAMPPRECISION);
pramp.rampRightVol = pramp.rightVol * (1 << VOLUMERAMPPRECISION);
pramp.nRampLength = nRampLength;
pramp.dwFlags.set(CHN_VOLUMERAMP);
}
return true;
}
// Apply stereo separation factor on an interleaved stereo/quad stream.
// count = Number of stereo sample pairs to process
// separation = -256...256 (negative values = swap L/R, 0 = mono, 128 = normal)
static void ApplyStereoSeparation(mixsample_t *mixBuf, std::size_t count, int32 separation)
{
#ifdef MPT_INTMIXER
const mixsample_t factor_num = separation; // 128 =^= 1.0f
const mixsample_t factor_den = MixerSettings::StereoSeparationScale; // 128
const mixsample_t normalize_den = 2; // mid/side pre/post normalization
const mixsample_t mid_den = normalize_den;
const mixsample_t side_num = factor_num;
const mixsample_t side_den = factor_den * normalize_den;
#else
const float normalize_factor = 0.5f; // cumulative mid/side normalization factor (1/sqrt(2))*(1/sqrt(2))
const float factor = static_cast<float>(separation) / static_cast<float>(MixerSettings::StereoSeparationScale); // sep / 128
const float mid_factor = normalize_factor;
const float side_factor = factor * normalize_factor;
#endif
for(std::size_t i = 0; i < count; i++)
{
mixsample_t l = mixBuf[0];
mixsample_t r = mixBuf[1];
mixsample_t m = l + r;
mixsample_t s = l - r;
#ifdef MPT_INTMIXER
m /= mid_den;
s = Util::muldiv(s, side_num, side_den);
#else
m *= mid_factor;
s *= side_factor;
#endif
l = m + s;
r = m - s;
mixBuf[0] = l;
mixBuf[1] = r;
mixBuf += 2;
}
}
static void ApplyStereoSeparation(mixsample_t *SoundFrontBuffer, mixsample_t *SoundRearBuffer, std::size_t channels, std::size_t countChunk, int32 separation)
{
if(separation == MixerSettings::StereoSeparationScale)
{ // identity
return;
}
if(channels >= 2) ApplyStereoSeparation(SoundFrontBuffer, countChunk, separation);
if(channels >= 4) ApplyStereoSeparation(SoundRearBuffer , countChunk, separation);
}
void CSoundFile::ProcessInputChannels(IAudioSource &source, std::size_t countChunk)
{
for(std::size_t channel = 0; channel < NUMMIXINPUTBUFFERS; ++channel)
{
std::fill(&(MixInputBuffer[channel][0]), &(MixInputBuffer[channel][countChunk]), 0);
}
mixsample_t * buffers[NUMMIXINPUTBUFFERS];
for(std::size_t channel = 0; channel < NUMMIXINPUTBUFFERS; ++channel)
{
buffers[channel] = MixInputBuffer[channel];
}
source.Process(mpt::audio_span_planar(buffers, m_MixerSettings.NumInputChannels, countChunk));
}
// Read one tick but skip all expensive rendering options
CSoundFile::samplecount_t CSoundFile::ReadOneTick()
{
const auto origMaxMixChannels = m_MixerSettings.m_nMaxMixChannels;
m_MixerSettings.m_nMaxMixChannels = 0;
while(m_PlayState.m_nBufferCount)
{
auto framesToRender = std::min(m_PlayState.m_nBufferCount, samplecount_t(MIXBUFFERSIZE));
CreateStereoMix(framesToRender);
m_PlayState.m_nBufferCount -= framesToRender;
m_PlayState.m_lTotalSampleCount += framesToRender;
}
m_MixerSettings.m_nMaxMixChannels = origMaxMixChannels;
if(ReadNote())
return m_PlayState.m_nBufferCount;
else
return 0;
}
CSoundFile::samplecount_t CSoundFile::Read(samplecount_t count, IAudioTarget &target, IAudioSource &source, std::optional<std::reference_wrapper<IMonitorOutput>> outputMonitor, std::optional<std::reference_wrapper<IMonitorInput>> inputMonitor)
{
MPT_ASSERT_ALWAYS(m_MixerSettings.IsValid());
samplecount_t countRendered = 0;
samplecount_t countToRender = count;
while(!m_SongFlags[SONG_ENDREACHED] && countToRender > 0)
{
// Update Channel Data
if(!m_PlayState.m_nBufferCount)
{
// Last tick or fade completely processed, find out what to do next
if(m_SongFlags[SONG_FADINGSONG])
{
// Song was faded out
m_SongFlags.set(SONG_ENDREACHED);
} else if(ReadNote())
{
// Render next tick (normal progress)
MPT_ASSERT(m_PlayState.m_nBufferCount > 0);
#ifdef MODPLUG_TRACKER
// Save pattern cue points for WAV rendering here (if we reached a new pattern, that is.)
if(m_PatternCuePoints != nullptr && (m_PatternCuePoints->empty() || m_PlayState.m_nCurrentOrder != m_PatternCuePoints->back().order))
{
PatternCuePoint cue;
cue.offset = countRendered;
cue.order = m_PlayState.m_nCurrentOrder;
cue.processed = false; // We don't know the base offset in the file here. It has to be added in the main conversion loop.
m_PatternCuePoints->push_back(cue);
}
#endif
} else
{
// No new pattern data
#ifdef MODPLUG_TRACKER
if((m_nMaxOrderPosition) && (m_PlayState.m_nCurrentOrder >= m_nMaxOrderPosition))
{
m_SongFlags.set(SONG_ENDREACHED);
}
#endif // MODPLUG_TRACKER
if(IsRenderingToDisc())
{
// Disable song fade when rendering or when requested in libopenmpt.
m_SongFlags.set(SONG_ENDREACHED);
} else
{ // end of song reached, fade it out
if(FadeSong(FADESONGDELAY)) // sets m_nBufferCount xor returns false
{ // FadeSong sets m_nBufferCount here
MPT_ASSERT(m_PlayState.m_nBufferCount > 0);
m_SongFlags.set(SONG_FADINGSONG);
} else
{
m_SongFlags.set(SONG_ENDREACHED);
}
}
}
}
if(m_SongFlags[SONG_ENDREACHED])
{
// Mix done.
// If we decide to continue the mix (possible in libopenmpt), the tick count
// is valid right now (0), meaning that no new row data will be processed.
// This would effectively prolong the last played row.
m_PlayState.m_nTickCount = m_PlayState.TicksOnRow();
break;
}
MPT_ASSERT(m_PlayState.m_nBufferCount > 0); // assert that we have actually something to do
const samplecount_t countChunk = std::min({ static_cast<samplecount_t>(MIXBUFFERSIZE), static_cast<samplecount_t>(m_PlayState.m_nBufferCount), static_cast<samplecount_t>(countToRender) });
if(m_MixerSettings.NumInputChannels > 0)
{
ProcessInputChannels(source, countChunk);
}
if(inputMonitor)
{
mixsample_t *buffers[NUMMIXINPUTBUFFERS];
for(std::size_t channel = 0; channel < NUMMIXINPUTBUFFERS; ++channel)
{
buffers[channel] = MixInputBuffer[channel];
}
inputMonitor->get().Process(mpt::audio_span_planar<const mixsample_t>(buffers, m_MixerSettings.NumInputChannels, countChunk));
}
CreateStereoMix(countChunk);
if(m_opl)
{
m_opl->Mix(MixSoundBuffer, countChunk, m_OPLVolumeFactor * m_nVSTiVolume / 48);
}
#ifndef NO_REVERB
m_Reverb.Process(MixSoundBuffer, ReverbSendBuffer, m_RvbROfsVol, m_RvbLOfsVol, countChunk);
#endif // NO_REVERB
#ifndef NO_PLUGINS
if(m_loadedPlugins)
{
ProcessPlugins(countChunk);
}
#endif // NO_PLUGINS
if(m_MixerSettings.gnChannels == 1)
{
MonoFromStereo(MixSoundBuffer, countChunk);
}
if(m_PlayConfig.getGlobalVolumeAppliesToMaster())
{
ProcessGlobalVolume(countChunk);
}
if(m_MixerSettings.m_nStereoSeparation != MixerSettings::StereoSeparationScale)
{
ProcessStereoSeparation(countChunk);
}
if(m_MixerSettings.DSPMask)
{
ProcessDSP(countChunk);
}
if(m_MixerSettings.gnChannels == 4)
{
InterleaveFrontRear(MixSoundBuffer, MixRearBuffer, countChunk);
}
if(outputMonitor)
{
outputMonitor->get().Process(mpt::audio_span_interleaved<const mixsample_t>(MixSoundBuffer, m_MixerSettings.gnChannels, countChunk));
}
target.Process(mpt::audio_span_interleaved<mixsample_t>(MixSoundBuffer, m_MixerSettings.gnChannels, countChunk));
// Buffer ready
countRendered += countChunk;
countToRender -= countChunk;
m_PlayState.m_nBufferCount -= countChunk;
m_PlayState.m_lTotalSampleCount += countChunk;
#ifdef MODPLUG_TRACKER
if(IsRenderingToDisc())
{
// Stop playback on F00 if no more voices are active.
// F00 sets the tick count to 65536 in FT2, so it just generates a reaaaally long row.
// Usually this command can be found at the end of a song to effectively stop playback.
// Since we don't want to render hours of silence, we are going to check if there are
// still any channels playing, and if that is no longer the case, we stop playback at
// the end of the next tick.
if(m_PlayState.m_nMusicSpeed == uint16_max && (m_nMixStat == 0 || m_PlayState.m_nGlobalVolume == 0) && GetType() == MOD_TYPE_XM && !m_PlayState.m_nBufferCount)
{
m_SongFlags.set(SONG_ENDREACHED);
}
}
#endif // MODPLUG_TRACKER
}
// mix done
return countRendered;
}
void CSoundFile::ProcessDSP(uint32 countChunk)
{
#ifndef NO_DSP
if(m_MixerSettings.DSPMask & SNDDSP_SURROUND)
{
m_Surround.Process(MixSoundBuffer, MixRearBuffer, countChunk, m_MixerSettings.gnChannels);
}
#endif // NO_DSP
#ifndef NO_DSP
if(m_MixerSettings.DSPMask & SNDDSP_MEGABASS)
{
m_MegaBass.Process(MixSoundBuffer, MixRearBuffer, countChunk, m_MixerSettings.gnChannels);
}
#endif // NO_DSP
#ifndef NO_EQ
if(m_MixerSettings.DSPMask & SNDDSP_EQ)
{
m_EQ.Process(MixSoundBuffer, MixRearBuffer, countChunk, m_MixerSettings.gnChannels);
}
#endif // NO_EQ
#ifndef NO_AGC
if(m_MixerSettings.DSPMask & SNDDSP_AGC)
{
m_AGC.Process(MixSoundBuffer, MixRearBuffer, countChunk, m_MixerSettings.gnChannels);
}
#endif // NO_AGC
#ifndef NO_DSP
if(m_MixerSettings.DSPMask & SNDDSP_BITCRUSH)
{
m_BitCrush.Process(MixSoundBuffer, MixRearBuffer, countChunk, m_MixerSettings.gnChannels);
}
#endif // NO_DSP
#if defined(NO_DSP) && defined(NO_EQ) && defined(NO_AGC)
MPT_UNREFERENCED_PARAMETER(countChunk);
#endif
}
/////////////////////////////////////////////////////////////////////////////
// Handles navigation/effects
bool CSoundFile::ProcessRow()
{
while(++m_PlayState.m_nTickCount >= m_PlayState.TicksOnRow())
{
const auto [ignoreRow, patternTransition] = NextRow(m_PlayState, m_SongFlags[SONG_BREAKTOROW]);
#ifdef MODPLUG_TRACKER
if(patternTransition)
{
HandlePatternTransitionEvents();
}
// "Lock row" editing feature
if(m_lockRowStart != ROWINDEX_INVALID && (m_PlayState.m_nRow < m_lockRowStart || m_PlayState.m_nRow > m_lockRowEnd) && !IsRenderingToDisc())
{
m_PlayState.m_nRow = m_lockRowStart;
}
// "Lock order" editing feature
if(Order().IsPositionLocked(m_PlayState.m_nCurrentOrder) && !IsRenderingToDisc())
{
m_PlayState.m_nCurrentOrder = m_lockOrderStart;
}
#else
MPT_UNUSED_VARIABLE(patternTransition);
#endif // MODPLUG_TRACKER
// Check if pattern is valid
if(!m_SongFlags[SONG_PATTERNLOOP])
{
m_PlayState.m_nPattern = (m_PlayState.m_nCurrentOrder < Order().size()) ? Order()[m_PlayState.m_nCurrentOrder] : Order.GetInvalidPatIndex();
if (m_PlayState.m_nPattern < Patterns.Size() && !Patterns[m_PlayState.m_nPattern].IsValid()) m_PlayState.m_nPattern = Order.GetIgnoreIndex();
while (m_PlayState.m_nPattern >= Patterns.Size())
{
// End of song?
if ((m_PlayState.m_nPattern == Order.GetInvalidPatIndex()) || (m_PlayState.m_nCurrentOrder >= Order().size()))
{
ORDERINDEX restartPosOverride = Order().GetRestartPos();
if(restartPosOverride == 0 && m_PlayState.m_nCurrentOrder <= Order().size() && m_PlayState.m_nCurrentOrder > 0)
{
// Subtune detection. Subtunes are separated by "---" order items, so if we're in a
// subtune and there's no restart position, we go to the first order of the subtune
// (i.e. the first order after the previous "---" item)
for(ORDERINDEX ord = m_PlayState.m_nCurrentOrder - 1; ord > 0; ord--)
{
if(Order()[ord] == Order.GetInvalidPatIndex())
{
// Jump back to first order of this subtune
restartPosOverride = ord + 1;
break;
}
}
}
// If channel resetting is disabled in MPT, we will emulate a pattern break (and we always do it if we're not in MPT)
#ifdef MODPLUG_TRACKER
if(!(TrackerSettings::Instance().m_dwPatternSetup & PATTERN_RESETCHANNELS))
#endif // MODPLUG_TRACKER
{
m_SongFlags.set(SONG_BREAKTOROW);
}
if (restartPosOverride == 0 && !m_SongFlags[SONG_BREAKTOROW])
{
//rewbs.instroVSTi: stop all VSTi at end of song, if looping.
StopAllVsti();
m_PlayState.m_nMusicSpeed = m_nDefaultSpeed;
m_PlayState.m_nMusicTempo = m_nDefaultTempo;
m_PlayState.m_nGlobalVolume = m_nDefaultGlobalVolume;
for(CHANNELINDEX i = 0; i < MAX_CHANNELS; i++)
{
auto &chn = m_PlayState.Chn[i];
if(chn.dwFlags[CHN_ADLIB] && m_opl)
{
m_opl->NoteCut(i);
}
chn.dwFlags.set(CHN_NOTEFADE | CHN_KEYOFF);
chn.nFadeOutVol = 0;
if(i < m_nChannels)
{
chn.nGlobalVol = ChnSettings[i].nVolume;
chn.nVolume = ChnSettings[i].nVolume;
chn.nPan = ChnSettings[i].nPan;
chn.nPanSwing = chn.nVolSwing = 0;
chn.nCutSwing = chn.nResSwing = 0;
chn.nOldVolParam = 0;
chn.oldOffset = 0;
chn.nOldHiOffset = 0;
chn.nPortamentoDest = 0;
if(!chn.nLength)
{
chn.dwFlags = ChnSettings[i].dwFlags;
chn.nLoopStart = 0;
chn.nLoopEnd = 0;
chn.pModInstrument = nullptr;
chn.pModSample = nullptr;
}
}
}
}
//Handle Repeat position
m_PlayState.m_nCurrentOrder = restartPosOverride;
m_SongFlags.reset(SONG_BREAKTOROW);
//If restart pos points to +++, move along
while(m_PlayState.m_nCurrentOrder < Order().size() && Order()[m_PlayState.m_nCurrentOrder] == Order.GetIgnoreIndex())
{
m_PlayState.m_nCurrentOrder++;
}
//Check for end of song or bad pattern
if (m_PlayState.m_nCurrentOrder >= Order().size()
|| !Order().IsValidPat(m_PlayState.m_nCurrentOrder))
{
m_visitedRows.Initialize(true);
return false;
}
} else
{
m_PlayState.m_nCurrentOrder++;
}
if (m_PlayState.m_nCurrentOrder < Order().size())
m_PlayState.m_nPattern = Order()[m_PlayState.m_nCurrentOrder];
else
m_PlayState.m_nPattern = Order.GetInvalidPatIndex();
if (m_PlayState.m_nPattern < Patterns.Size() && !Patterns[m_PlayState.m_nPattern].IsValid())
m_PlayState.m_nPattern = Order.GetIgnoreIndex();
}
m_PlayState.m_nNextOrder = m_PlayState.m_nCurrentOrder;
#ifdef MODPLUG_TRACKER
if ((m_nMaxOrderPosition) && (m_PlayState.m_nCurrentOrder >= m_nMaxOrderPosition)) return false;
#endif // MODPLUG_TRACKER
}
// Weird stuff?
if (!Patterns.IsValidPat(m_PlayState.m_nPattern))
return false;
// Did we jump to an invalid row?
if (m_PlayState.m_nRow >= Patterns[m_PlayState.m_nPattern].GetNumRows()) m_PlayState.m_nRow = 0;
// Has this row been visited before? We might want to stop playback now.
// But: We will not mark the row as modified if the song is not in loop mode but
// the pattern loop (editor flag, not to be confused with the pattern loop effect)
// flag is set - because in that case, the module would stop after the first pattern loop...
const bool overrideLoopCheck = (m_nRepeatCount != -1) && m_SongFlags[SONG_PATTERNLOOP];
if(!overrideLoopCheck && m_visitedRows.Visit(m_PlayState.m_nCurrentOrder, m_PlayState.m_nRow, m_PlayState.Chn, ignoreRow))
{
if(m_nRepeatCount)
{
// repeat count == -1 means repeat infinitely.
if(m_nRepeatCount > 0)
{
m_nRepeatCount--;
}
// Forget all but the current row.
m_visitedRows.Initialize(true);
m_visitedRows.Visit(m_PlayState.m_nCurrentOrder, m_PlayState.m_nRow, m_PlayState.Chn, ignoreRow);
} else
{
#ifdef MODPLUG_TRACKER
// Let's check again if this really is the end of the song.
// The visited rows vector might have been screwed up while editing...
// This is of course not possible during rendering to WAV, so we ignore that case.
bool isReallyAtEnd = IsRenderingToDisc();
if(!isReallyAtEnd)
{
for(const auto &t : GetLength(eNoAdjust, GetLengthTarget(true)))
{
if(t.lastOrder == m_PlayState.m_nCurrentOrder && t.lastRow == m_PlayState.m_nRow)
{
isReallyAtEnd = true;
break;
}
}
}
if(isReallyAtEnd)
{
// This is really the song's end!
m_visitedRows.Initialize(true);
return false;
} else
{
// Ok, this is really dirty, but we have to update the visited rows vector...
GetLength(eAdjustOnlyVisitedRows, GetLengthTarget(m_PlayState.m_nCurrentOrder, m_PlayState.m_nRow));
}
#else
if(m_SongFlags[SONG_PLAYALLSONGS])
{
// When playing all subsongs consecutively, first search for any hidden subsongs...
if(!m_visitedRows.GetFirstUnvisitedRow(m_PlayState.m_nCurrentOrder, m_PlayState.m_nRow, true))
{
// ...and then try the next sequence.
m_PlayState.m_nNextOrder = m_PlayState.m_nCurrentOrder = 0;
m_PlayState.m_nNextRow = m_PlayState.m_nRow = 0;
if(Order.GetCurrentSequenceIndex() >= Order.GetNumSequences() - 1)
{
Order.SetSequence(0);
m_visitedRows.Initialize(true);
return false;
}
Order.SetSequence(Order.GetCurrentSequenceIndex() + 1);
m_visitedRows.Initialize(true);
}
// When jumping to the next subsong, stop all playing notes from the previous song...
const auto muteFlag = CSoundFile::GetChannelMuteFlag();
for(CHANNELINDEX i = 0; i < MAX_CHANNELS; i++)
m_PlayState.Chn[i].Reset(ModChannel::resetSetPosFull, *this, i, muteFlag);
StopAllVsti();
// ...and the global playback information.
m_PlayState.m_nMusicSpeed = m_nDefaultSpeed;
m_PlayState.m_nMusicTempo = m_nDefaultTempo;
m_PlayState.m_nGlobalVolume = m_nDefaultGlobalVolume;
m_PlayState.m_nNextOrder = m_PlayState.m_nCurrentOrder;
m_PlayState.m_nNextRow = m_PlayState.m_nRow;
if(Order().size() > m_PlayState.m_nCurrentOrder)
m_PlayState.m_nPattern = Order()[m_PlayState.m_nCurrentOrder];
m_visitedRows.Visit(m_PlayState.m_nCurrentOrder, m_PlayState.m_nRow, m_PlayState.Chn, ignoreRow);
if (!Patterns.IsValidPat(m_PlayState.m_nPattern))
return false;
} else
{
m_visitedRows.Initialize(true);
return false;
}
#endif // MODPLUG_TRACKER
}
}
SetupNextRow(m_PlayState, m_SongFlags[SONG_PATTERNLOOP]);
// Reset channel values
ModCommand *m = Patterns[m_PlayState.m_nPattern].GetpModCommand(m_PlayState.m_nRow, 0);
for (ModChannel *pChn = m_PlayState.Chn, *pEnd = pChn + m_nChannels; pChn != pEnd; pChn++, m++)
{
// First, handle some quirks that happen after the last tick of the previous row...
if(m_playBehaviour[KST3PortaAfterArpeggio]
&& pChn->nCommand == CMD_ARPEGGIO // Previous row state!
&& (m->command == CMD_PORTAMENTOUP || m->command == CMD_PORTAMENTODOWN))
{
// In ST3, a portamento immediately following an arpeggio continues where the arpeggio left off.
// Test case: PortaAfterArp.s3m
pChn->nPeriod = GetPeriodFromNote(pChn->nArpeggioLastNote, pChn->nFineTune, pChn->nC5Speed);
}
if(m_playBehaviour[kMODOutOfRangeNoteDelay]
&& !m->IsNote()
&& pChn->rowCommand.IsNote()
&& pChn->rowCommand.command == CMD_MODCMDEX && (pChn->rowCommand.param & 0xF0) == 0xD0
&& (pChn->rowCommand.param & 0x0Fu) >= m_PlayState.m_nMusicSpeed)
{
// In ProTracker, a note triggered by an out-of-range note delay can be heard on the next row
// if there is no new note on that row.
// Test case: NoteDelay-NextRow.mod
pChn->nPeriod = GetPeriodFromNote(pChn->rowCommand.note, pChn->nFineTune, 0);
}
if(m_playBehaviour[kMODTempoOnSecondTick] && !m_playBehaviour[kMODVBlankTiming] && m_PlayState.m_nMusicSpeed == 1 && pChn->rowCommand.command == CMD_TEMPO)
{
// ProTracker sets the tempo after the first tick. This block handles the case of one tick per row.
// Test case: TempoChange.mod
m_PlayState.m_nMusicTempo = TEMPO(std::max(ModCommand::PARAM(1), pChn->rowCommand.param), 0);
}
pChn->rowCommand = *m;
pChn->rightVol = pChn->newRightVol;
pChn->leftVol = pChn->newLeftVol;
pChn->dwFlags.reset(CHN_VIBRATO | CHN_TREMOLO);
if(!m_playBehaviour[kITVibratoTremoloPanbrello]) pChn->nPanbrelloOffset = 0;
pChn->nCommand = CMD_NONE;
pChn->m_plugParamValueStep = 0;
}
// Now that we know which pattern we're on, we can update time signatures (global or pattern-specific)
UpdateTimeSignature();
if(ignoreRow)
{
m_PlayState.m_nTickCount = m_PlayState.m_nMusicSpeed;
continue;
}
break;
}
// Should we process tick0 effects?
if (!m_PlayState.m_nMusicSpeed) m_PlayState.m_nMusicSpeed = 1;
//End of row? stop pattern step (aka "play row").
#ifdef MODPLUG_TRACKER
if (m_PlayState.m_nTickCount >= m_PlayState.TicksOnRow() - 1)
{
if(m_SongFlags[SONG_STEP])
{
m_SongFlags.reset(SONG_STEP);
m_SongFlags.set(SONG_PAUSED);
}
}
#endif // MODPLUG_TRACKER
if (m_PlayState.m_nTickCount)
{
m_SongFlags.reset(SONG_FIRSTTICK);
if(!(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2))
&& (GetType() != MOD_TYPE_MOD || m_SongFlags[SONG_PT_MODE]) // Fix infinite loop in "GamerMan " by MrGamer, which was made with FT2
&& m_PlayState.m_nTickCount < m_PlayState.TicksOnRow())
{
// Emulate first tick behaviour if Row Delay is set.
// Test cases: PatternDelaysRetrig.it, PatternDelaysRetrig.s3m, PatternDelaysRetrig.xm, PatternDelaysRetrig.mod
if(!(m_PlayState.m_nTickCount % (m_PlayState.m_nMusicSpeed + m_PlayState.m_nFrameDelay)))
{
m_SongFlags.set(SONG_FIRSTTICK);
}
}
} else
{
m_SongFlags.set(SONG_FIRSTTICK);
m_SongFlags.reset(SONG_BREAKTOROW);
}
// Update Effects
return ProcessEffects();
}
std::pair<bool, bool> CSoundFile::NextRow(PlayState &playState, const bool breakRow) const
{
// When having an EEx effect on the same row as a Dxx jump, the target row is not played in ProTracker.
// Test case: DelayBreak.mod (based on condom_corruption by Travolta)
const bool ignoreRow = playState.m_nPatternDelay > 1 && breakRow && GetType() == MOD_TYPE_MOD;
// Done with the last row of the pattern or jumping somewhere else (could also be a result of pattern loop to row 0, but that doesn't matter here)
const bool patternTransition = playState.m_nNextRow == 0 || breakRow;
if(patternTransition && GetType() == MOD_TYPE_S3M)
{
// Reset pattern loop start
// Test case: LoopReset.s3m
for(CHANNELINDEX i = 0; i < GetNumChannels(); i++)
{
playState.Chn[i].nPatternLoop = 0;
}
}
playState.m_nPatternDelay = 0;
playState.m_nFrameDelay = 0;
playState.m_nTickCount = 0;
playState.m_nRow = playState.m_nNextRow;
playState.m_nCurrentOrder = playState.m_nNextOrder;
return {ignoreRow, patternTransition};
}
void CSoundFile::SetupNextRow(PlayState &playState, const bool patternLoop) const
{
playState.m_nNextRow = playState.m_nRow + 1;
if(playState.m_nNextRow >= Patterns[playState.m_nPattern].GetNumRows())
{
if(!patternLoop)
playState.m_nNextOrder = playState.m_nCurrentOrder + 1;
playState.m_nNextRow = 0;
// FT2 idiosyncrasy: When E60 is used on a pattern row x, the following pattern also starts from row x
// instead of the beginning of the pattern, unless there was a Bxx or Dxx effect.
if(m_playBehaviour[kFT2LoopE60Restart])
{
playState.m_nNextRow = playState.m_nextPatStartRow;
playState.m_nextPatStartRow = 0;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////
// Channel effect processing
// Calculate delta for Vibrato / Tremolo / Panbrello effect
int CSoundFile::GetVibratoDelta(int type, int position) const
{
// IT compatibility: IT has its own, more precise tables
if(m_playBehaviour[kITVibratoTremoloPanbrello])
{
position &= 0xFF;
switch(type & 0x03)
{
case 0: // Sine
default:
return ITSinusTable[position];
case 1: // Ramp down
return 64 - (position + 1) / 2;
case 2: // Square
return position < 128 ? 64 : 0;
case 3: // Random
return mpt::random<int, 7>(AccessPRNG()) - 0x40;
}
} else if(GetType() & (MOD_TYPE_DIGI | MOD_TYPE_DBM))
{
// Other waveforms are not supported.
static constexpr int8 DBMSinus[] =
{
33, 52, 69, 84, 96, 107, 116, 122, 125, 127, 125, 122, 116, 107, 96, 84,
69, 52, 33, 13, -8, -31, -54, -79, -104,-128, -104, -79, -54, -31, -8, 13,
};
return DBMSinus[(position / 2u) & 0x1F];
} else
{
position &= 0x3F;
switch(type & 0x03)
{
case 0: // Sine
default:
return ModSinusTable[position];
case 1: // Ramp down
return (position < 32 ? 0 : 255) - position * 4;
case 2: // Square
return position < 32 ? 127 : -127;
case 3: // Random
return ModRandomTable[position];
}
}
}
void CSoundFile::ProcessVolumeSwing(ModChannel &chn, int &vol) const
{
if(m_playBehaviour[kITSwingBehaviour])
{
vol += chn.nVolSwing;
Limit(vol, 0, 64);
} else if(m_playBehaviour[kMPTOldSwingBehaviour])
{
vol += chn.nVolSwing;
Limit(vol, 0, 256);
} else
{
chn.nVolume += chn.nVolSwing;
Limit(chn.nVolume, 0, 256);
vol = chn.nVolume;
chn.nVolSwing = 0;
}
}
void CSoundFile::ProcessPanningSwing(ModChannel &chn) const
{
if(m_playBehaviour[kITSwingBehaviour] || m_playBehaviour[kMPTOldSwingBehaviour])
{
chn.nRealPan = chn.nPan + chn.nPanSwing;
Limit(chn.nRealPan, 0, 256);
} else
{
chn.nPan += chn.nPanSwing;
Limit(chn.nPan, 0, 256);
chn.nPanSwing = 0;
chn.nRealPan = chn.nPan;
}
}
void CSoundFile::ProcessTremolo(ModChannel &chn, int &vol) const
{
if (chn.dwFlags[CHN_TREMOLO])
{
if(m_SongFlags.test_all(SONG_FIRSTTICK | SONG_PT_MODE))
{
// ProTracker doesn't apply tremolo nor advance on the first tick.
// Test case: VibratoReset.mod
return;
}
// IT compatibility: Why would you not want to execute tremolo at volume 0?
if(vol > 0 || m_playBehaviour[kITVibratoTremoloPanbrello])
{
// IT compatibility: We don't need a different attenuation here because of the different tables we're going to use
const uint8 attenuation = ((GetType() & (MOD_TYPE_XM | MOD_TYPE_MOD)) || m_playBehaviour[kITVibratoTremoloPanbrello]) ? 5 : 6;
int delta = GetVibratoDelta(chn.nTremoloType, chn.nTremoloPos);
if((chn.nTremoloType & 0x03) == 1 && m_playBehaviour[kFT2MODTremoloRampWaveform])
{
// FT2 compatibility: Tremolo ramp down / triangle implementation is weird and affected by vibrato position (copypaste bug)
// Test case: TremoloWaveforms.xm, TremoloVibrato.xm
uint8 ramp = (chn.nTremoloPos * 4u) & 0x7F;
// Volume-colum vibrato gets executed first in FT2, so we may need to advance the vibrato position first
uint32 vibPos = chn.nVibratoPos;
if(!m_SongFlags[SONG_FIRSTTICK] && chn.dwFlags[CHN_VIBRATO])
vibPos += chn.nVibratoSpeed;
if((vibPos & 0x3F) >= 32)
ramp ^= 0x7F;
if((chn.nTremoloPos & 0x3F) >= 32)
delta = -ramp;
else
delta = ramp;
}
if(GetType() != MOD_TYPE_DMF)
{
vol += (delta * chn.nTremoloDepth) / (1 << attenuation);
} else
{
// Tremolo in DMF always attenuates by a percentage of the current note volume
vol -= (vol * chn.nTremoloDepth * (64 - delta)) / (128 * 64);
}
}
if(!m_SongFlags[SONG_FIRSTTICK] || ((GetType() & (MOD_TYPE_IT|MOD_TYPE_MPT)) && !m_SongFlags[SONG_ITOLDEFFECTS]))
{
// IT compatibility: IT has its own, more precise tables
if(m_playBehaviour[kITVibratoTremoloPanbrello])
chn.nTremoloPos += 4 * chn.nTremoloSpeed;
else
chn.nTremoloPos += chn.nTremoloSpeed;
}
}
}
void CSoundFile::ProcessTremor(CHANNELINDEX nChn, int &vol)
{
ModChannel &chn = m_PlayState.Chn[nChn];
if(m_playBehaviour[kFT2Tremor])
{
// FT2 Compatibility: Weird XM tremor.
// Test case: Tremor.xm
if(chn.nTremorCount & 0x80)
{
if(!m_SongFlags[SONG_FIRSTTICK] && chn.nCommand == CMD_TREMOR)
{
chn.nTremorCount &= ~0x20;
if(chn.nTremorCount == 0x80)
{
// Reached end of off-time
chn.nTremorCount = (chn.nTremorParam >> 4) | 0xC0;
} else if(chn.nTremorCount == 0xC0)
{
// Reached end of on-time
chn.nTremorCount = (chn.nTremorParam & 0x0F) | 0x80;
} else
{
chn.nTremorCount--;
}
chn.dwFlags.set(CHN_FASTVOLRAMP);
}
if((chn.nTremorCount & 0xE0) == 0x80)
{
vol = 0;
}
}
} else if(chn.nCommand == CMD_TREMOR)
{
// IT compatibility 12. / 13.: Tremor
if(m_playBehaviour[kITTremor])
{
if((chn.nTremorCount & 0x80) && chn.nLength)
{
if (chn.nTremorCount == 0x80)
chn.nTremorCount = (chn.nTremorParam >> 4) | 0xC0;
else if (chn.nTremorCount == 0xC0)
chn.nTremorCount = (chn.nTremorParam & 0x0F) | 0x80;
else
chn.nTremorCount--;
}
if((chn.nTremorCount & 0xC0) == 0x80)
vol = 0;
} else
{
uint8 ontime = chn.nTremorParam >> 4;
uint8 n = ontime + (chn.nTremorParam & 0x0F); // Total tremor cycle time (On + Off)
if ((!(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))) || m_SongFlags[SONG_ITOLDEFFECTS])
{
n += 2;
ontime++;
}
uint8 tremcount = chn.nTremorCount;
if(!(GetType() & MOD_TYPE_XM))
{
if (tremcount >= n) tremcount = 0;
if (tremcount >= ontime) vol = 0;
chn.nTremorCount = tremcount + 1;
} else
{
if(m_SongFlags[SONG_FIRSTTICK])
{
// tremcount is only 0 on the first tremor tick after triggering a note.
if(tremcount > 0)
{
tremcount--;
}
} else
{
chn.nTremorCount = tremcount + 1;
}
if (tremcount % n >= ontime) vol = 0;
}
}
chn.dwFlags.set(CHN_FASTVOLRAMP);
}
#ifndef NO_PLUGINS
// Plugin tremor
if(chn.nCommand == CMD_TREMOR && chn.pModInstrument && chn.pModInstrument->nMixPlug
&& !chn.pModInstrument->dwFlags[INS_MUTE]
&& !chn.dwFlags[CHN_MUTE | CHN_SYNCMUTE]
&& ModCommand::IsNote(chn.nLastNote))
{
const ModInstrument *pIns = chn.pModInstrument;
IMixPlugin *pPlugin = m_MixPlugins[pIns->nMixPlug - 1].pMixPlugin;
if(pPlugin)
{
const bool isPlaying = pPlugin->IsNotePlaying(chn.nLastNote, nChn);
if(vol == 0 && isPlaying)
pPlugin->MidiCommand(*pIns, chn.nLastNote + NOTE_MAX_SPECIAL, 0, nChn);
else if(vol != 0 && !isPlaying)
pPlugin->MidiCommand(*pIns, chn.nLastNote, static_cast<uint16>(chn.nVolume), nChn);
}
}
#endif // NO_PLUGINS
}
bool CSoundFile::IsEnvelopeProcessed(const ModChannel &chn, EnvelopeType env) const
{
if(chn.pModInstrument == nullptr)
{
return false;
}
const InstrumentEnvelope &insEnv = chn.pModInstrument->GetEnvelope(env);
// IT Compatibility: S77/S79/S7B do not disable the envelope, they just pause the counter
// Test cases: s77.it, EnvLoops.xm, PanSustainRelease.xm
bool playIfPaused = m_playBehaviour[kITEnvelopePositionHandling] || m_playBehaviour[kFT2PanSustainRelease];
return ((chn.GetEnvelope(env).flags[ENV_ENABLED] || (insEnv.dwFlags[ENV_ENABLED] && playIfPaused))
&& !insEnv.empty());
}
void CSoundFile::ProcessVolumeEnvelope(ModChannel &chn, int &vol) const
{
if(IsEnvelopeProcessed(chn, ENV_VOLUME))
{
const ModInstrument *pIns = chn.pModInstrument;
if(m_playBehaviour[kITEnvelopePositionHandling] && chn.VolEnv.nEnvPosition == 0)
{
// If the envelope is disabled at the very same moment as it is triggered, we do not process anything.
return;
}
const int envpos = chn.VolEnv.nEnvPosition - (m_playBehaviour[kITEnvelopePositionHandling] ? 1 : 0);
// Get values in [0, 256]
int envval = pIns->VolEnv.GetValueFromPosition(envpos, 256);
// if we are in the release portion of the envelope,
// rescale envelope factor so that it is proportional to the release point
// and release envelope beginning.
if(pIns->VolEnv.nReleaseNode != ENV_RELEASE_NODE_UNSET
&& chn.VolEnv.nEnvValueAtReleaseJump != NOT_YET_RELEASED)
{
int envValueAtReleaseJump = chn.VolEnv.nEnvValueAtReleaseJump;
int envValueAtReleaseNode = pIns->VolEnv[pIns->VolEnv.nReleaseNode].value * 4;
//If we have just hit the release node, force the current env value
//to be that of the release node. This works around the case where
// we have another node at the same position as the release node.
if(envpos == pIns->VolEnv[pIns->VolEnv.nReleaseNode].tick)
envval = envValueAtReleaseNode;
if(m_playBehaviour[kLegacyReleaseNode])
{
// Old, hard to grasp release node behaviour (additive)
int relativeVolumeChange = (envval - envValueAtReleaseNode) * 2;
envval = envValueAtReleaseJump + relativeVolumeChange;
} else
{
// New behaviour, truly relative to release node
if(envValueAtReleaseNode > 0)
envval = envValueAtReleaseJump * envval / envValueAtReleaseNode;
else
envval = 0;
}
}
vol = (vol * Clamp(envval, 0, 512)) / 256;
}
}
void CSoundFile::ProcessPanningEnvelope(ModChannel &chn) const
{
if(IsEnvelopeProcessed(chn, ENV_PANNING))
{
const ModInstrument *pIns = chn.pModInstrument;
if(m_playBehaviour[kITEnvelopePositionHandling] && chn.PanEnv.nEnvPosition == 0)
{
// If the envelope is disabled at the very same moment as it is triggered, we do not process anything.
return;
}
const int envpos = chn.PanEnv.nEnvPosition - (m_playBehaviour[kITEnvelopePositionHandling] ? 1 : 0);
// Get values in [-32, 32]
const int envval = pIns->PanEnv.GetValueFromPosition(envpos, 64) - 32;
int pan = chn.nRealPan;
if(pan >= 128)
{
pan += (envval * (256 - pan)) / 32;
} else
{
pan += (envval * (pan)) / 32;
}
chn.nRealPan = Clamp(pan, 0, 256);
}
}
int CSoundFile::ProcessPitchFilterEnvelope(ModChannel &chn, int32 &period) const
{
if(IsEnvelopeProcessed(chn, ENV_PITCH))
{
const ModInstrument *pIns = chn.pModInstrument;
if(m_playBehaviour[kITEnvelopePositionHandling] && chn.PitchEnv.nEnvPosition == 0)
{
// If the envelope is disabled at the very same moment as it is triggered, we do not process anything.
return -1;
}
const int envpos = chn.PitchEnv.nEnvPosition - (m_playBehaviour[kITEnvelopePositionHandling] ? 1 : 0);
// Get values in [-256, 256]
#ifdef MODPLUG_TRACKER
const int32 range = ENVELOPE_MAX;
const int32 amp = 512;
#else
// TODO: AMS2 envelopes behave differently when linear slides are off - emulate with 15 * (-128...127) >> 6
// Copy over vibrato behaviour for that?
const int32 range = GetType() == MOD_TYPE_AMS ? uint8_max : ENVELOPE_MAX;
int32 amp;
switch(GetType())
{
case MOD_TYPE_AMS: amp = 64; break;
case MOD_TYPE_MDL: amp = 192; break;
default: amp = 512;
}
#endif
const int envval = pIns->PitchEnv.GetValueFromPosition(envpos, amp, range) - amp / 2;
if(chn.PitchEnv.flags[ENV_FILTER])
{
// Filter Envelope: controls cutoff frequency
return SetupChannelFilter(chn, !chn.dwFlags[CHN_FILTER], envval);
} else
{
// Pitch Envelope
if(chn.HasCustomTuning())
{
if(chn.nFineTune != envval)
{
chn.nFineTune = mpt::saturate_cast<int16>(envval);
chn.m_CalculateFreq = true;
//Preliminary tests indicated that this behavior
//is very close to original(with 12TET) when finestep count
//is 15.
}
} else //Original behavior
{
const bool useFreq = PeriodsAreFrequencies();
const uint32 (&upTable)[256] = useFreq ? LinearSlideUpTable : LinearSlideDownTable;
const uint32 (&downTable)[256] = useFreq ? LinearSlideDownTable : LinearSlideUpTable;
int l = envval;
if(l < 0)
{
l = -l;
LimitMax(l, 255);
period = Util::muldiv(period, downTable[l], 65536);
} else
{
LimitMax(l, 255);
period = Util::muldiv(period, upTable[l], 65536);
}
} //End: Original behavior.
}
}
return -1;
}
void CSoundFile::IncrementEnvelopePosition(ModChannel &chn, EnvelopeType envType) const
{
ModChannel::EnvInfo &chnEnv = chn.GetEnvelope(envType);
if(chn.pModInstrument == nullptr || !chnEnv.flags[ENV_ENABLED])
{
return;
}
// Increase position
uint32 position = chnEnv.nEnvPosition + (m_playBehaviour[kITEnvelopePositionHandling] ? 0 : 1);
const InstrumentEnvelope &insEnv = chn.pModInstrument->GetEnvelope(envType);
if(insEnv.empty())
{
return;
}
bool endReached = false;
if(!m_playBehaviour[kITEnvelopePositionHandling])
{
// FT2-style envelope processing.
if(insEnv.dwFlags[ENV_LOOP])
{
// Normal loop active
uint32 end = insEnv[insEnv.nLoopEnd].tick;
if(!(GetType() & (MOD_TYPE_XM | MOD_TYPE_MT2))) end++;
// FT2 compatibility: If the sustain point is at the loop end and the sustain loop has been released, don't loop anymore.
// Test case: EnvLoops.xm
const bool escapeLoop = (insEnv.nLoopEnd == insEnv.nSustainEnd && insEnv.dwFlags[ENV_SUSTAIN] && chn.dwFlags[CHN_KEYOFF] && m_playBehaviour[kFT2EnvelopeEscape]);
if(position == end && !escapeLoop)
{
position = insEnv[insEnv.nLoopStart].tick;
}
}
if(insEnv.dwFlags[ENV_SUSTAIN] && !chn.dwFlags[CHN_KEYOFF])
{
// Envelope sustained
if(position == insEnv[insEnv.nSustainEnd].tick + 1u)
{
position = insEnv[insEnv.nSustainStart].tick;
// FT2 compatibility: If the panning envelope reaches its sustain point before key-off, it stays there forever.
// Test case: PanSustainRelease.xm
if(m_playBehaviour[kFT2PanSustainRelease] && envType == ENV_PANNING && !chn.dwFlags[CHN_KEYOFF])
{
chnEnv.flags.reset(ENV_ENABLED);
}
}
} else
{
// Limit to last envelope point
if(position > insEnv.back().tick)
{
// Env of envelope
position = insEnv.back().tick;
endReached = true;
}
}
} else
{
// IT envelope processing.
// Test case: EnvLoops.it
uint32 start, end;
// IT compatiblity: OpenMPT processes the key-off flag earlier than IT. Grab the flag from the previous tick instead.
// Test case: EnvOffLength.it
if(insEnv.dwFlags[ENV_SUSTAIN] && !chn.dwOldFlags[CHN_KEYOFF] && (chnEnv.nEnvValueAtReleaseJump == NOT_YET_RELEASED || m_playBehaviour[kReleaseNodePastSustainBug]))
{
// Envelope sustained
start = insEnv[insEnv.nSustainStart].tick;
end = insEnv[insEnv.nSustainEnd].tick + 1;
} else if(insEnv.dwFlags[ENV_LOOP])
{
// Normal loop active
start = insEnv[insEnv.nLoopStart].tick;
end = insEnv[insEnv.nLoopEnd].tick + 1;
} else
{
// Limit to last envelope point
start = end = insEnv.back().tick;
if(position > end)
{
// Env of envelope
endReached = true;
}
}
if(position >= end)
{
position = start;
}
}
if(envType == ENV_VOLUME && endReached)
{
// Special handling for volume envelopes at end of envelope
if((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) || (chn.dwFlags[CHN_KEYOFF] && GetType() != MOD_TYPE_MDL))
{
chn.dwFlags.set(CHN_NOTEFADE);
}
if(insEnv.back().value == 0 && (chn.nMasterChn > 0 || (GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))))
{
// Stop channel if the last envelope node is silent anyway.
chn.dwFlags.set(CHN_NOTEFADE);
chn.nFadeOutVol = 0;
chn.nRealVolume = 0;
chn.nCalcVolume = 0;
}
}
chnEnv.nEnvPosition = position + (m_playBehaviour[kITEnvelopePositionHandling] ? 1 : 0);
}
void CSoundFile::IncrementEnvelopePositions(ModChannel &chn) const
{
if (chn.isFirstTick && GetType() == MOD_TYPE_MED)
return;
IncrementEnvelopePosition(chn, ENV_VOLUME);
IncrementEnvelopePosition(chn, ENV_PANNING);
IncrementEnvelopePosition(chn, ENV_PITCH);
}
void CSoundFile::ProcessInstrumentFade(ModChannel &chn, int &vol) const
{
// FadeOut volume
if(chn.dwFlags[CHN_NOTEFADE] && chn.pModInstrument != nullptr)
{
const ModInstrument *pIns = chn.pModInstrument;
uint32 fadeout = pIns->nFadeOut;
if (fadeout)
{
chn.nFadeOutVol -= fadeout * 2;
if (chn.nFadeOutVol <= 0) chn.nFadeOutVol = 0;
vol = (vol * chn.nFadeOutVol) / 65536;
} else if (!chn.nFadeOutVol)
{
vol = 0;
}
}
}
void CSoundFile::ProcessPitchPanSeparation(int32 &pan, int note, const ModInstrument &instr)
{
if(!instr.nPPS || note == NOTE_NONE)
return;
// with PPS = 16 / PPC = C-5, E-6 will pan hard right (and D#6 will not)
int32 delta = (note - instr.nPPC - NOTE_MIN) * instr.nPPS / 2;
pan = Clamp(pan + delta, 0, 256);
}
void CSoundFile::ProcessPanbrello(ModChannel &chn) const
{
int pdelta = chn.nPanbrelloOffset;
if(chn.rowCommand.command == CMD_PANBRELLO)
{
uint32 panpos;
// IT compatibility: IT has its own, more precise tables
if(m_playBehaviour[kITVibratoTremoloPanbrello])
panpos = chn.nPanbrelloPos;
else
panpos = ((chn.nPanbrelloPos + 0x10) >> 2);
pdelta = GetVibratoDelta(chn.nPanbrelloType, panpos);
// IT compatibility: Sample-and-hold style random panbrello (tremolo and vibrato don't use this mechanism in IT)
// Test case: RandomWaveform.it
if(m_playBehaviour[kITSampleAndHoldPanbrello] && chn.nPanbrelloType == 3)
{
if(chn.nPanbrelloPos == 0 || chn.nPanbrelloPos >= chn.nPanbrelloSpeed)
{
chn.nPanbrelloPos = 0;
chn.nPanbrelloRandomMemory = static_cast<int8>(pdelta);
}
chn.nPanbrelloPos++;
pdelta = chn.nPanbrelloRandomMemory;
} else
{
chn.nPanbrelloPos += chn.nPanbrelloSpeed;
}
// IT compatibility: Panbrello effect is active until next note or panning command.
// Test case: PanbrelloHold.it
if(m_playBehaviour[kITPanbrelloHold])
{
chn.nPanbrelloOffset = static_cast<int8>(pdelta);
}
}
if(pdelta)
{
pdelta = ((pdelta * (int)chn.nPanbrelloDepth) + 2) / 8;
pdelta += chn.nRealPan;
chn.nRealPan = Clamp(pdelta, 0, 256);
}
}
void CSoundFile::ProcessArpeggio(CHANNELINDEX nChn, int32 &period, Tuning::NOTEINDEXTYPE &arpeggioSteps)
{
ModChannel &chn = m_PlayState.Chn[nChn];
#ifndef NO_PLUGINS
// Plugin arpeggio
if(chn.pModInstrument && chn.pModInstrument->nMixPlug
&& !chn.pModInstrument->dwFlags[INS_MUTE]
&& !chn.dwFlags[CHN_MUTE | CHN_SYNCMUTE])
{
const ModInstrument *pIns = chn.pModInstrument;
IMixPlugin *pPlugin = m_MixPlugins[pIns->nMixPlug - 1].pMixPlugin;
if(pPlugin)
{
uint8 step = 0;
const bool arpOnRow = (chn.rowCommand.command == CMD_ARPEGGIO);
const ModCommand::NOTE lastNote = ModCommand::IsNote(chn.nLastNote) ? static_cast<ModCommand::NOTE>(pIns->NoteMap[chn.nLastNote - NOTE_MIN]) : static_cast<ModCommand::NOTE>(NOTE_NONE);
if(arpOnRow)
{
switch(m_PlayState.m_nTickCount % 3)
{
case 1: step = chn.nArpeggio >> 4; break;
case 2: step = chn.nArpeggio & 0x0F; break;
}
chn.nArpeggioBaseNote = lastNote;
}
// Trigger new note:
// - If there's an arpeggio on this row and
// - the note to trigger is not the same as the previous arpeggio note or
// - a pattern note has just been triggered on this tick
// - If there's no arpeggio
// - but an arpeggio note is still active and
// - there's no note stop or new note that would stop it anyway
if((arpOnRow && chn.nArpeggioLastNote != chn.nArpeggioBaseNote + step && (!m_SongFlags[SONG_FIRSTTICK] || !chn.rowCommand.IsNote()))
|| (!arpOnRow && chn.rowCommand.note == NOTE_NONE && chn.nArpeggioLastNote != NOTE_NONE))
SendMIDINote(nChn, chn.nArpeggioBaseNote + step, static_cast<uint16>(chn.nVolume));
// Stop note:
// - If some arpeggio note is still registered or
// - When starting an arpeggio on a row with no other note on it, stop some possibly still playing note.
if(chn.nArpeggioLastNote != NOTE_NONE)
SendMIDINote(nChn, chn.nArpeggioLastNote + NOTE_MAX_SPECIAL, 0);
else if(arpOnRow && m_SongFlags[SONG_FIRSTTICK] && !chn.rowCommand.IsNote() && ModCommand::IsNote(lastNote))
SendMIDINote(nChn, lastNote + NOTE_MAX_SPECIAL, 0);
if(chn.rowCommand.command == CMD_ARPEGGIO)
chn.nArpeggioLastNote = chn.nArpeggioBaseNote + step;
else
chn.nArpeggioLastNote = NOTE_NONE;
}
}
#endif // NO_PLUGINS
if(chn.nCommand == CMD_ARPEGGIO)
{
if(chn.HasCustomTuning())
{
switch(m_PlayState.m_nTickCount % 3)
{
case 0: arpeggioSteps = 0; break;
case 1: arpeggioSteps = chn.nArpeggio >> 4; break;
case 2: arpeggioSteps = chn.nArpeggio & 0x0F; break;
}
chn.m_CalculateFreq = true;
chn.m_ReCalculateFreqOnFirstTick = true;
} else
{
if(GetType() == MOD_TYPE_MT2 && m_SongFlags[SONG_FIRSTTICK])
{
// MT2 resets any previous portamento when an arpeggio occurs.
chn.nPeriod = period = GetPeriodFromNote(chn.nNote, chn.nFineTune, chn.nC5Speed);
}
if(m_playBehaviour[kITArpeggio])
{
//IT playback compatibility 01 & 02
// Pattern delay restarts tick counting. Not quite correct yet!
const uint32 tick = m_PlayState.m_nTickCount % (m_PlayState.m_nMusicSpeed + m_PlayState.m_nFrameDelay);
if(chn.nArpeggio != 0)
{
uint32 arpRatio = 65536;
switch(tick % 3)
{
case 1: arpRatio = LinearSlideUpTable[(chn.nArpeggio >> 4) * 16]; break;
case 2: arpRatio = LinearSlideUpTable[(chn.nArpeggio & 0x0F) * 16]; break;
}
if(PeriodsAreFrequencies())
period = Util::muldivr(period, arpRatio, 65536);
else
period = Util::muldivr(period, 65536, arpRatio);
}
} else if(m_playBehaviour[kFT2Arpeggio])
{
// FastTracker 2: Swedish tracker logic (TM) arpeggio
if(!m_SongFlags[SONG_FIRSTTICK])
{
// Arpeggio is added on top of current note, but cannot do it the IT way because of
// the behaviour in ArpeggioClamp.xm.
// Test case: ArpSlide.xm
uint32 note = 0;
// The fact that arpeggio behaves in a totally fucked up way at 16 ticks/row or more is that the arpeggio offset LUT only has 16 entries in FT2.
// At more than 16 ticks/row, FT2 reads into the vibrato table, which is placed right after the arpeggio table.
// Test case: Arpeggio.xm
int arpPos = m_PlayState.m_nMusicSpeed - (m_PlayState.m_nTickCount % m_PlayState.m_nMusicSpeed);
if(arpPos > 16)
arpPos = 2;
else if(arpPos == 16)
arpPos = 0;
else
arpPos %= 3;
switch(arpPos)
{
case 1: note = (chn.nArpeggio >> 4); break;
case 2: note = (chn.nArpeggio & 0x0F); break;
}
if(arpPos != 0)
{
// Arpeggio is added on top of current note, but cannot do it the IT way because of
// the behaviour in ArpeggioClamp.xm.
// Test case: ArpSlide.xm
note += GetNoteFromPeriod(period, chn.nFineTune, chn.nC5Speed);
period = GetPeriodFromNote(note, chn.nFineTune, chn.nC5Speed);
// FT2 compatibility: FT2 has a different note limit for Arpeggio.
// Test case: ArpeggioClamp.xm
if(note >= 108 + NOTE_MIN)
{
period = std::max(static_cast<uint32>(period), GetPeriodFromNote(108 + NOTE_MIN, 0, chn.nC5Speed));
}
}
}
}
// Other trackers
else
{
uint32 tick = m_PlayState.m_nTickCount;
// TODO other likely formats for MOD case: MED, OKT, etc
uint8 note = (GetType() != MOD_TYPE_MOD) ? chn.nNote : static_cast<uint8>(GetNoteFromPeriod(period, chn.nFineTune, chn.nC5Speed));
if(GetType() & (MOD_TYPE_DBM | MOD_TYPE_DIGI))
tick += 2;
switch(tick % 3)
{
case 1: note += (chn.nArpeggio >> 4); break;
case 2: note += (chn.nArpeggio & 0x0F); break;
}
if(note != chn.nNote || (GetType() & (MOD_TYPE_DBM | MOD_TYPE_DIGI | MOD_TYPE_STM)) || m_playBehaviour[KST3PortaAfterArpeggio])
{
if(m_SongFlags[SONG_PT_MODE])
{
// Weird arpeggio wrap-around in ProTracker.
// Test case: ArpWraparound.mod, and the snare sound in "Jim is dead" by doh.
if(note == NOTE_MIDDLEC + 24)
{
period = int32_max;
return;
} else if(note > NOTE_MIDDLEC + 24)
{
note -= 37;
}
}
period = GetPeriodFromNote(note, chn.nFineTune, chn.nC5Speed);
if(GetType() & (MOD_TYPE_DBM | MOD_TYPE_DIGI | MOD_TYPE_PSM | MOD_TYPE_STM | MOD_TYPE_OKT))
{
// The arpeggio note offset remains effective after the end of the current row in ScreamTracker 2.
// This fixes the flute lead in MORPH.STM by Skaven, pattern 27.
// Note that ScreamTracker 2.24 handles arpeggio slightly differently: It only considers the lower
// nibble, and switches to that note halfway through the row.
chn.nPeriod = period;
} else if(m_playBehaviour[KST3PortaAfterArpeggio])
{
chn.nArpeggioLastNote = note;
}
}
}
}
}
}
void CSoundFile::ProcessVibrato(CHANNELINDEX nChn, int32 &period, Tuning::RATIOTYPE &vibratoFactor)
{
ModChannel &chn = m_PlayState.Chn[nChn];
if(chn.dwFlags[CHN_VIBRATO])
{
const bool advancePosition = !m_SongFlags[SONG_FIRSTTICK] || ((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && !(m_SongFlags[SONG_ITOLDEFFECTS]));
if(GetType() == MOD_TYPE_669)
{
if(chn.nVibratoPos % 2u)
{
period += chn.nVibratoDepth * 167; // Already multiplied by 4, and it seems like the real factor here is 669... how original =)
}
chn.nVibratoPos++;
return;
}
// IT compatibility: IT has its own, more precise tables and pre-increments the vibrato position
if(advancePosition && m_playBehaviour[kITVibratoTremoloPanbrello])
chn.nVibratoPos += 4 * chn.nVibratoSpeed;
int vdelta = GetVibratoDelta(chn.nVibratoType, chn.nVibratoPos);
if(chn.HasCustomTuning())
{
//Hack implementation: Scaling vibratofactor to [0.95; 1.05]
//using figure from above tables and vibratodepth parameter
vibratoFactor += 0.05f * (vdelta * chn.nVibratoDepth) / (128.0f * 60.0f);
chn.m_CalculateFreq = true;
chn.m_ReCalculateFreqOnFirstTick = false;
if(m_PlayState.m_nTickCount + 1 == m_PlayState.m_nMusicSpeed)
chn.m_ReCalculateFreqOnFirstTick = true;
} else
{
// Original behaviour
if(m_SongFlags.test_all(SONG_FIRSTTICK | SONG_PT_MODE) || ((GetType() & (MOD_TYPE_DIGI | MOD_TYPE_DBM)) && m_SongFlags[SONG_FIRSTTICK]))
{
// ProTracker doesn't apply vibrato nor advance on the first tick.
// Test case: VibratoReset.mod
return;
} else if((GetType() & (MOD_TYPE_XM | MOD_TYPE_MOD)) && (chn.nVibratoType & 0x03) == 1)
{
// FT2 compatibility: Vibrato ramp down table is upside down.
// Test case: VibratoWaveforms.xm
vdelta = -vdelta;
}
uint32 vdepth;
// IT compatibility: correct vibrato depth
if(m_playBehaviour[kITVibratoTremoloPanbrello])
{
// Yes, vibrato goes backwards with old effects enabled!
if(m_SongFlags[SONG_ITOLDEFFECTS])
{
// Test case: vibrato-oldfx.it
vdepth = 5;
} else
{
// Test case: vibrato.it
vdepth = 6;
vdelta = -vdelta;
}
} else
{
if(m_SongFlags[SONG_S3MOLDVIBRATO])
vdepth = 5;
else if(GetType() == MOD_TYPE_DTM)
vdepth = 8;
else if(GetType() & (MOD_TYPE_DBM | MOD_TYPE_MTM))
vdepth = 7;
else if((GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)) && !m_SongFlags[SONG_ITOLDEFFECTS])
vdepth = 7;
else
vdepth = 6;
// ST3 compatibility: Do not distinguish between vibrato types in effect memory
// Test case: VibratoTypeChange.s3m
if(m_playBehaviour[kST3VibratoMemory] && chn.rowCommand.command == CMD_FINEVIBRATO)
vdepth += 2;
}
vdelta = (-vdelta * static_cast<int>(chn.nVibratoDepth)) / (1 << vdepth);
DoFreqSlide(chn, period, vdelta);
// Process MIDI vibrato for plugins:
#ifndef NO_PLUGINS
IMixPlugin *plugin = GetChannelInstrumentPlugin(m_PlayState.Chn[nChn]);
if(plugin != nullptr)
{
// If the Pitch Wheel Depth is configured correctly (so it's the same as the plugin's PWD),
// MIDI vibrato will sound identical to vibrato with linear slides enabled.
int8 pwd = 2;
if(chn.pModInstrument != nullptr)
{
pwd = chn.pModInstrument->midiPWD;
}
plugin->MidiVibrato(vdelta, pwd, nChn);
}
#endif // NO_PLUGINS
}
// Advance vibrato position - IT updates on every tick, unless "old effects" are enabled (in this case it only updates on non-first ticks like other trackers)
// IT compatibility: IT has its own, more precise tables and pre-increments the vibrato position
if(advancePosition && !m_playBehaviour[kITVibratoTremoloPanbrello])
chn.nVibratoPos += chn.nVibratoSpeed;
} else if(chn.dwOldFlags[CHN_VIBRATO])
{
// Stop MIDI vibrato for plugins:
#ifndef NO_PLUGINS
IMixPlugin *plugin = GetChannelInstrumentPlugin(m_PlayState.Chn[nChn]);
if(plugin != nullptr)
{
plugin->MidiVibrato(0, 0, nChn);
}
#endif // NO_PLUGINS
}
}
void CSoundFile::ProcessSampleAutoVibrato(ModChannel &chn, int32 &period, Tuning::RATIOTYPE &vibratoFactor, int &nPeriodFrac) const
{
// Sample Auto-Vibrato
if(chn.pModSample != nullptr && chn.pModSample->nVibDepth)
{
const ModSample *pSmp = chn.pModSample;
const bool hasTuning = chn.HasCustomTuning();
// In IT compatible mode, we use always frequencies, otherwise we use periods, which are upside down.
// In this context, the "up" tables refer to the tables that increase frequency, and the down tables are the ones that decrease frequency.
const bool useFreq = PeriodsAreFrequencies();
const uint32 (&upTable)[256] = useFreq ? LinearSlideUpTable : LinearSlideDownTable;
const uint32 (&downTable)[256] = useFreq ? LinearSlideDownTable : LinearSlideUpTable;
const uint32 (&fineUpTable)[16] = useFreq ? FineLinearSlideUpTable : FineLinearSlideDownTable;
const uint32 (&fineDownTable)[16] = useFreq ? FineLinearSlideDownTable : FineLinearSlideUpTable;
// IT compatibility: Autovibrato is so much different in IT that I just put this in a separate code block, to get rid of a dozen IsCompatibilityMode() calls.
if(m_playBehaviour[kITVibratoTremoloPanbrello] && !hasTuning && GetType() != MOD_TYPE_MT2)
{
if(!pSmp->nVibRate)
return;
// Schism's autovibrato code
/*
X86 Assembler from ITTECH.TXT:
1) Mov AX, [SomeVariableNameRelatingToVibrato]
2) Add AL, Rate
3) AdC AH, 0
4) AH contains the depth of the vibrato as a fine-linear slide.
5) Mov [SomeVariableNameRelatingToVibrato], AX ; For the next cycle.
*/
const int vibpos = chn.nAutoVibPos & 0xFF;
int adepth = chn.nAutoVibDepth; // (1)
adepth += pSmp->nVibSweep; // (2 & 3)
LimitMax(adepth, static_cast<int>(pSmp->nVibDepth * 256u));
chn.nAutoVibDepth = adepth; // (5)
adepth /= 256; // (4)
chn.nAutoVibPos += pSmp->nVibRate;
int vdelta;
switch(pSmp->nVibType)
{
case VIB_RANDOM:
vdelta = mpt::random<int, 7>(AccessPRNG()) - 0x40;
break;
case VIB_RAMP_DOWN:
vdelta = 64 - (vibpos + 1) / 2;
break;
case VIB_RAMP_UP:
vdelta = ((vibpos + 1) / 2) - 64;
break;
case VIB_SQUARE:
vdelta = vibpos < 128 ? 64 : 0;
break;
case VIB_SINE:
default:
vdelta = ITSinusTable[vibpos];
break;
}
vdelta = (vdelta * adepth) / 64;
uint32 l = std::abs(vdelta);
LimitMax(period, Util::MaxValueOfType(period) / 256);
period *= 256;
if(vdelta < 0)
{
vdelta = Util::muldiv(period, downTable[l / 4u], 0x10000) - period;
if (l & 0x03)
{
vdelta += Util::muldiv(period, fineDownTable[l & 0x03], 0x10000) - period;
}
} else
{
vdelta = Util::muldiv(period, upTable[l / 4u], 0x10000) - period;
if (l & 0x03)
{
vdelta += Util::muldiv(period, fineUpTable[l & 0x03], 0x10000) - period;
}
}
period = (period + vdelta) / 256;
nPeriodFrac = vdelta & 0xFF;
} else
{
// MPT's autovibrato code
if (pSmp->nVibSweep == 0 && !(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT)))
{
chn.nAutoVibDepth = pSmp->nVibDepth * 256;
} else
{
// Calculate current autovibrato depth using vibsweep
if (GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))
{
chn.nAutoVibDepth += pSmp->nVibSweep * 2u;
} else
{
if(!chn.dwFlags[CHN_KEYOFF])
{
chn.nAutoVibDepth += (pSmp->nVibDepth * 256u) / pSmp->nVibSweep;
}
}
LimitMax(chn.nAutoVibDepth, static_cast<int>(pSmp->nVibDepth * 256u));
}
chn.nAutoVibPos += pSmp->nVibRate;
int vdelta;
switch(pSmp->nVibType)
{
case VIB_RANDOM:
vdelta = ModRandomTable[chn.nAutoVibPos & 0x3F];
chn.nAutoVibPos++;
break;
case VIB_RAMP_DOWN:
vdelta = ((0x40 - (chn.nAutoVibPos / 2u)) & 0x7F) - 0x40;
break;
case VIB_RAMP_UP:
vdelta = ((0x40 + (chn.nAutoVibPos / 2u)) & 0x7F) - 0x40;
break;
case VIB_SQUARE:
vdelta = (chn.nAutoVibPos & 128) ? +64 : -64;
break;
case VIB_SINE:
default:
if(GetType() != MOD_TYPE_MT2)
{
vdelta = -ITSinusTable[chn.nAutoVibPos & 0xFF];
} else
{
// Fix flat-sounding pads in "another worlds" by Eternal Engine.
// Vibrato starts at the maximum amplitude of the sine wave
// and the vibrato frequency never decreases below the original note's frequency.
vdelta = (-ITSinusTable[(chn.nAutoVibPos + 192) & 0xFF] + 64) / 2;
}
}
int n = (vdelta * chn.nAutoVibDepth) / 256;
if(hasTuning)
{
//Vib sweep is not taken into account here.
vibratoFactor += 0.05F * pSmp->nVibDepth * vdelta / 4096.0f; //4096 == 64^2
//See vibrato for explanation.
chn.m_CalculateFreq = true;
/*
Finestep vibrato:
const float autoVibDepth = pSmp->nVibDepth * val / 4096.0f; //4096 == 64^2
vibratoFineSteps += static_cast<CTuning::FINESTEPTYPE>(chn.pModInstrument->pTuning->GetFineStepCount() * autoVibDepth);
chn.m_CalculateFreq = true;
*/
}
else //Original behavior
{
if (GetType() != MOD_TYPE_XM)
{
int df1, df2;
if (n < 0)
{
n = -n;
uint32 n1 = n / 256;
df1 = downTable[n1];
df2 = downTable[n1+1];
} else
{
uint32 n1 = n / 256;
df1 = upTable[n1];
df2 = upTable[n1+1];
}
n /= 4;
period = Util::muldiv(period, df1 + ((df2 - df1) * (n & 0x3F) / 64), 256);
nPeriodFrac = period & 0xFF;
period /= 256;
} else
{
period += (n / 64);
}
} //Original MPT behavior
}
}
}
void CSoundFile::ProcessRamping(ModChannel &chn) const
{
chn.leftRamp = chn.rightRamp = 0;
LimitMax(chn.newLeftVol, int32_max >> VOLUMERAMPPRECISION);
LimitMax(chn.newRightVol, int32_max >> VOLUMERAMPPRECISION);
if(chn.dwFlags[CHN_VOLUMERAMP] && (chn.leftVol != chn.newLeftVol || chn.rightVol != chn.newRightVol))
{
const bool rampUp = (chn.newLeftVol > chn.leftVol) || (chn.newRightVol > chn.rightVol);
int32 rampLength, globalRampLength, instrRampLength = 0;
rampLength = globalRampLength = (rampUp ? m_MixerSettings.GetVolumeRampUpSamples() : m_MixerSettings.GetVolumeRampDownSamples());
//XXXih: add real support for bidi ramping here
if(m_playBehaviour[kFT2VolumeRamping] && (GetType() & MOD_TYPE_XM))
{
// apply FT2-style super-soft volume ramping (5ms), overriding openmpt settings
rampLength = globalRampLength = Util::muldivr(5, m_MixerSettings.gdwMixingFreq, 1000);
}
if(chn.pModInstrument != nullptr && rampUp)
{
instrRampLength = chn.pModInstrument->nVolRampUp;
rampLength = instrRampLength ? (m_MixerSettings.gdwMixingFreq * instrRampLength / 100000) : globalRampLength;
}
const bool enableCustomRamp = (instrRampLength > 0);
if(!rampLength)
{
rampLength = 1;
}
int32 leftDelta = ((chn.newLeftVol - chn.leftVol) * (1 << VOLUMERAMPPRECISION));
int32 rightDelta = ((chn.newRightVol - chn.rightVol) * (1 << VOLUMERAMPPRECISION));
if(!enableCustomRamp)
{
// Extra-smooth ramping, unless we're forced to use the default values
if((chn.leftVol | chn.rightVol) && (chn.newLeftVol | chn.newRightVol) && !chn.dwFlags[CHN_FASTVOLRAMP])
{
rampLength = m_PlayState.m_nBufferCount;
Limit(rampLength, globalRampLength, int32(1 << (VOLUMERAMPPRECISION - 1)));
}
}
chn.leftRamp = leftDelta / rampLength;
chn.rightRamp = rightDelta / rampLength;
chn.leftVol = chn.newLeftVol - ((chn.leftRamp * rampLength) / (1 << VOLUMERAMPPRECISION));
chn.rightVol = chn.newRightVol - ((chn.rightRamp * rampLength) / (1 << VOLUMERAMPPRECISION));
if (chn.leftRamp|chn.rightRamp)
{
chn.nRampLength = rampLength;
} else
{
chn.dwFlags.reset(CHN_VOLUMERAMP);
chn.leftVol = chn.newLeftVol;
chn.rightVol = chn.newRightVol;
}
} else
{
chn.dwFlags.reset(CHN_VOLUMERAMP);
chn.leftVol = chn.newLeftVol;
chn.rightVol = chn.newRightVol;
}
chn.rampLeftVol = chn.leftVol * (1 << VOLUMERAMPPRECISION);
chn.rampRightVol = chn.rightVol * (1 << VOLUMERAMPPRECISION);
chn.dwFlags.reset(CHN_FASTVOLRAMP);
}
// Returns channel increment and frequency with FREQ_FRACBITS fractional bits
std::pair<SamplePosition, uint32> CSoundFile::GetChannelIncrement(const ModChannel &chn, uint32 period, int periodFrac) const
{
uint32 freq;
if(!chn.HasCustomTuning())
freq = GetFreqFromPeriod(period, chn.nC5Speed, periodFrac);
else
freq = chn.nPeriod;
const ModInstrument *ins = chn.pModInstrument;
if(int32 finetune = chn.microTuning; finetune != 0)
{
if(ins)
finetune *= ins->midiPWD;
if(finetune)
freq = mpt::saturate_round<uint32>(freq * std::pow(2.0, finetune / (12.0 * 256.0 * 128.0)));
}
// Applying Pitch/Tempo lock
if(ins && ins->pitchToTempoLock.GetRaw())
{
freq = Util::muldivr(freq, m_PlayState.m_nMusicTempo.GetRaw(), ins->pitchToTempoLock.GetRaw());
}
// Avoid increment to overflow and become negative with unrealisticly high frequencies.
LimitMax(freq, uint32(int32_max));
return {SamplePosition::Ratio(freq, m_MixerSettings.gdwMixingFreq << FREQ_FRACBITS), freq};
}
////////////////////////////////////////////////////////////////////////////////////////////
// Handles envelopes & mixer setup
bool CSoundFile::ReadNote()
{
#ifdef MODPLUG_TRACKER
// Checking end of row ?
if(m_SongFlags[SONG_PAUSED])
{
m_PlayState.m_nTickCount = 0;
if (!m_PlayState.m_nMusicSpeed) m_PlayState.m_nMusicSpeed = 6;
if (!m_PlayState.m_nMusicTempo.GetRaw()) m_PlayState.m_nMusicTempo.Set(125);
} else
#endif // MODPLUG_TRACKER
{
if(!ProcessRow())
return false;
}
////////////////////////////////////////////////////////////////////////////////////
if (m_PlayState.m_nMusicTempo.GetRaw() == 0) return false;
m_PlayState.m_nSamplesPerTick = GetTickDuration(m_PlayState);
m_PlayState.m_nBufferCount = m_PlayState.m_nSamplesPerTick;
// Master Volume + Pre-Amplification / Attenuation setup
uint32 nMasterVol;
{
CHANNELINDEX nchn32 = Clamp(m_nChannels, CHANNELINDEX(1), CHANNELINDEX(31));
uint32 mastervol;
if (m_PlayConfig.getUseGlobalPreAmp())
{
int realmastervol = m_MixerSettings.m_nPreAmp;
if (realmastervol > 0x80)
{
//Attenuate global pre-amp depending on num channels
realmastervol = 0x80 + ((realmastervol - 0x80) * (nchn32 + 4)) / 16;
}
mastervol = (realmastervol * (m_nSamplePreAmp)) / 64;
} else
{
//Preferred option: don't use global pre-amp at all.
mastervol = m_nSamplePreAmp;
}
if (m_PlayConfig.getUseGlobalPreAmp())
{
uint32 attenuation =
#ifndef NO_AGC
(m_MixerSettings.DSPMask & SNDDSP_AGC) ? PreAmpAGCTable[nchn32 / 2u] :
#endif
PreAmpTable[nchn32 / 2u];
if(attenuation < 1) attenuation = 1;
nMasterVol = (mastervol << 7) / attenuation;
} else
{
nMasterVol = mastervol;
}
}
////////////////////////////////////////////////////////////////////////////////////
// Update channels data
m_nMixChannels = 0;
for (CHANNELINDEX nChn = 0; nChn < MAX_CHANNELS; nChn++)
{
ModChannel &chn = m_PlayState.Chn[nChn];
// FT2 Compatibility: Prevent notes to be stopped after a fadeout. This way, a portamento effect can pick up a faded instrument which is long enough.
// This occurs for example in the bassline (channel 11) of jt_burn.xm. I hope this won't break anything else...
// I also suppose this could decrease mixing performance a bit, but hey, which CPU can't handle 32 muted channels these days... :-)
if(chn.dwFlags[CHN_NOTEFADE] && (!(chn.nFadeOutVol|chn.leftVol|chn.rightVol)) && !m_playBehaviour[kFT2ProcessSilentChannels])
{
chn.nLength = 0;
chn.nROfs = chn.nLOfs = 0;
}
// Check for unused channel
if(chn.dwFlags[CHN_MUTE] || (nChn >= m_nChannels && !chn.nLength))
{
if(nChn < m_nChannels)
{
// Process MIDI macros on channels that are currently muted.
ProcessMacroOnChannel(nChn);
}
chn.nLeftVU = chn.nRightVU = 0;
continue;
}
// Reset channel data
chn.increment = SamplePosition(0);
chn.nRealVolume = 0;
chn.nCalcVolume = 0;
chn.nRampLength = 0;
//Aux variables
Tuning::RATIOTYPE vibratoFactor = 1;
Tuning::NOTEINDEXTYPE arpeggioSteps = 0;
const ModInstrument *pIns = chn.pModInstrument;
// Calc Frequency
int32 period = 0;
// Also process envelopes etc. when there's a plugin on this channel, for possible fake automation using volume and pan data.
// We only care about master channels, though, since automation only "happens" on them.
const bool samplePlaying = (chn.nPeriod && chn.nLength);
const bool plugAssigned = (nChn < m_nChannels) && (ChnSettings[nChn].nMixPlugin || (chn.pModInstrument != nullptr && chn.pModInstrument->nMixPlug));
if (samplePlaying || plugAssigned)
{
int vol = chn.nVolume;
int insVol = chn.nInsVol; // This is the "SV * IV" value in ITTECH.TXT
ProcessVolumeSwing(chn, m_playBehaviour[kITSwingBehaviour] ? insVol : vol);
ProcessPanningSwing(chn);
ProcessTremolo(chn, vol);
ProcessTremor(nChn, vol);
// Clip volume and multiply (extend to 14 bits)
Limit(vol, 0, 256);
vol <<= 6;
// Process Envelopes
if (pIns)
{
if(m_playBehaviour[kITEnvelopePositionHandling])
{
// In IT compatible mode, envelope position indices are shifted by one for proper envelope pausing,
// so we have to update the position before we actually process the envelopes.
// When using MPT behaviour, we get the envelope position for the next tick while we are still calculating the current tick,
// which then results in wrong position information when the envelope is paused on the next row.
// Test cases: s77.it
IncrementEnvelopePositions(chn);
}
ProcessVolumeEnvelope(chn, vol);
ProcessInstrumentFade(chn, vol);
ProcessPanningEnvelope(chn);
if(!m_playBehaviour[kITPitchPanSeparation] && chn.nNote != NOTE_NONE && chn.pModInstrument && chn.pModInstrument->nPPS != 0)
ProcessPitchPanSeparation(chn.nRealPan, chn.nNote, *chn.pModInstrument);
} else
{
// No Envelope: key off => note cut
if(chn.dwFlags[CHN_NOTEFADE]) // 1.41-: CHN_KEYOFF|CHN_NOTEFADE
{
chn.nFadeOutVol = 0;
vol = 0;
}
}
if(chn.isPaused)
vol = 0;
// vol is 14-bits
if (vol)
{
// IMPORTANT: chn.nRealVolume is 14 bits !!!
// -> Util::muldiv( 14+8, 6+6, 18); => RealVolume: 14-bit result (22+12-20)
if(chn.dwFlags[CHN_SYNCMUTE])
{
chn.nRealVolume = 0;
} else if (m_PlayConfig.getGlobalVolumeAppliesToMaster())
{
// Don't let global volume affect level of sample if
// Global volume is going to be applied to master output anyway.
chn.nRealVolume = Util::muldiv(vol * MAX_GLOBAL_VOLUME, chn.nGlobalVol * insVol, 1 << 20);
} else
{
chn.nRealVolume = Util::muldiv(vol * m_PlayState.m_nGlobalVolume, chn.nGlobalVol * insVol, 1 << 20);
}
}
chn.nCalcVolume = vol; // Update calculated volume for MIDI macros
// ST3 only clamps the final output period, but never the channel's internal period.
// Test case: PeriodLimit.s3m
if (chn.nPeriod < m_nMinPeriod
&& GetType() != MOD_TYPE_S3M
&& !PeriodsAreFrequencies())
{
chn.nPeriod = m_nMinPeriod;
} else if(chn.nPeriod >= m_nMaxPeriod && m_playBehaviour[kApplyUpperPeriodLimit] && !PeriodsAreFrequencies())
{
// ...but on the other hand, ST3's SoundBlaster driver clamps the maximum channel period.
// Test case: PeriodLimitUpper.s3m
chn.nPeriod = m_nMaxPeriod;
}
if(m_playBehaviour[kFT2Periods]) Clamp(chn.nPeriod, 1, 31999);
period = chn.nPeriod;
// When glissando mode is set to semitones, clamp to the next halftone.
if((chn.dwFlags & (CHN_GLISSANDO | CHN_PORTAMENTO)) == (CHN_GLISSANDO | CHN_PORTAMENTO)
&& (!m_SongFlags[SONG_PT_MODE] || (chn.rowCommand.IsPortamento() && !m_SongFlags[SONG_FIRSTTICK])))
{
if(period != chn.cachedPeriod)
{
// Only recompute this whole thing in case the base period has changed.
chn.cachedPeriod = period;
chn.glissandoPeriod = GetPeriodFromNote(GetNoteFromPeriod(period, chn.nFineTune, chn.nC5Speed), chn.nFineTune, chn.nC5Speed);
}
period = chn.glissandoPeriod;
}
ProcessArpeggio(nChn, period, arpeggioSteps);
// Preserve Amiga freq limits.
// In ST3, the frequency is always clamped to periods 113 to 856, while in ProTracker,
// the limit is variable, depending on the finetune of the sample.
// The int32_max test is for the arpeggio wrap-around in ProcessArpeggio().
// Test case: AmigaLimits.s3m, AmigaLimitsFinetune.mod
if(m_SongFlags[SONG_AMIGALIMITS | SONG_PT_MODE] && period != int32_max)
{
int limitLow = 113 * 4, limitHigh = 856 * 4;
if(GetType() != MOD_TYPE_S3M)
{
const int tableOffset = XM2MODFineTune(chn.nFineTune) * 12;
limitLow = ProTrackerTunedPeriods[tableOffset + 11] / 2;
limitHigh = ProTrackerTunedPeriods[tableOffset] * 2;
// Amiga cannot actually keep up with lower periods
if(limitLow < 113 * 4) limitLow = 113 * 4;
}
Limit(period, limitLow, limitHigh);
Limit(chn.nPeriod, limitLow, limitHigh);
}
ProcessPanbrello(chn);
}
// IT Compatibility: Ensure that there is no pan swing, panbrello, panning envelopes, etc. applied on surround channels.
// Test case: surround-pan.it
if(chn.dwFlags[CHN_SURROUND] && !m_SongFlags[SONG_SURROUNDPAN] && m_playBehaviour[kITNoSurroundPan])
{
chn.nRealPan = 128;
}
// Now that all relevant envelopes etc. have been processed, we can parse the MIDI macro data.
ProcessMacroOnChannel(nChn);
// After MIDI macros have been processed, we can also process the pitch / filter envelope and other pitch-related things.
if(samplePlaying)
{
int cutoff = ProcessPitchFilterEnvelope(chn, period);
if(cutoff >= 0 && chn.dwFlags[CHN_ADLIB] && m_opl)
{
// Cutoff doubles as modulator intensity for FM instruments
m_opl->Volume(nChn, static_cast<uint8>(cutoff / 4), true);
}
}
if(chn.rowCommand.volcmd == VOLCMD_VIBRATODEPTH &&
(chn.rowCommand.command == CMD_VIBRATO || chn.rowCommand.command == CMD_VIBRATOVOL || chn.rowCommand.command == CMD_FINEVIBRATO))
{
if(GetType() == MOD_TYPE_XM)
{
// XM Compatibility: Vibrato should be advanced twice (but not added up) if both volume-column and effect column vibrato is present.
// Effect column vibrato parameter has precedence if non-zero.
// Test case: VibratoDouble.xm
if(!m_SongFlags[SONG_FIRSTTICK])
chn.nVibratoPos += chn.nVibratoSpeed;
} else if(GetType() & (MOD_TYPE_IT | MOD_TYPE_MPT))
{
// IT Compatibility: Vibrato should be applied twice if both volume-colum and effect column vibrato is present.
// Volume column vibrato parameter has precedence if non-zero.
// Test case: VibratoDouble.it
Vibrato(chn, chn.rowCommand.vol);
ProcessVibrato(nChn, period, vibratoFactor);
}
}
// Plugins may also receive vibrato
ProcessVibrato(nChn, period, vibratoFactor);
if(samplePlaying)
{
int nPeriodFrac = 0;
ProcessSampleAutoVibrato(chn, period, vibratoFactor, nPeriodFrac);
// Final Period
// ST3 only clamps the final output period, but never the channel's internal period.
// Test case: PeriodLimit.s3m
if (period <= m_nMinPeriod)
{
if(m_playBehaviour[kST3LimitPeriod]) chn.nLength = 0; // Pattern 15 in watcha.s3m
period = m_nMinPeriod;
}
const bool hasTuning = chn.HasCustomTuning();
if(hasTuning)
{
if(chn.m_CalculateFreq || (chn.m_ReCalculateFreqOnFirstTick && m_PlayState.m_nTickCount == 0))
{
chn.RecalcTuningFreq(vibratoFactor, arpeggioSteps, *this);
if(!chn.m_CalculateFreq)
chn.m_ReCalculateFreqOnFirstTick = false;
else
chn.m_CalculateFreq = false;
}
}
auto [ninc, freq] = GetChannelIncrement(chn, period, nPeriodFrac);
#ifndef MODPLUG_TRACKER
ninc.MulDiv(m_nFreqFactor, 65536);
#endif // !MODPLUG_TRACKER
if(ninc.IsZero())
{
ninc.Set(0, 1);
}
chn.increment = ninc;
if((chn.dwFlags & (CHN_ADLIB | CHN_MUTE | CHN_SYNCMUTE)) == CHN_ADLIB && m_opl)
{
const bool doProcess = m_playBehaviour[kOPLFlexibleNoteOff] || !chn.dwFlags[CHN_NOTEFADE] || GetType() == MOD_TYPE_S3M;
if(doProcess && !(GetType() == MOD_TYPE_S3M && chn.dwFlags[CHN_KEYOFF]))
{
// In ST3, a sample rate of 8363 Hz is mapped to middle-C, which is 261.625 Hz in a tempered scale at A4 = 440.
// Hence, we have to translate our "sample rate" into pitch.
auto milliHertz = Util::muldivr_unsigned(freq, 261625, 8363 << FREQ_FRACBITS);
const bool keyOff = chn.dwFlags[CHN_KEYOFF] || (chn.dwFlags[CHN_NOTEFADE] && chn.nFadeOutVol == 0);
if(!m_playBehaviour[kOPLNoteStopWith0Hz] || !keyOff)
m_opl->Frequency(nChn, milliHertz, keyOff, m_playBehaviour[kOPLBeatingOscillators]);
}
if(doProcess)
{
// Scale volume to OPL range (0...63).
m_opl->Volume(nChn, static_cast<uint8>(Util::muldivr_unsigned(chn.nCalcVolume * chn.nGlobalVol * chn.nInsVol, 63, 1 << 26)), false);
chn.nRealPan = m_opl->Pan(nChn, chn.nRealPan) * 128 + 128;
}
// Deallocate OPL channels for notes that are most definitely never going to play again.
if(const auto *ins = chn.pModInstrument; ins != nullptr
&& (ins->VolEnv.dwFlags & (ENV_ENABLED | ENV_LOOP | ENV_SUSTAIN)) == ENV_ENABLED
&& !ins->VolEnv.empty()
&& chn.GetEnvelope(ENV_VOLUME).nEnvPosition >= ins->VolEnv.back().tick
&& ins->VolEnv.back().value == 0)
{
m_opl->NoteCut(nChn);
if(!m_playBehaviour[kOPLNoResetAtEnvelopeEnd])
chn.dwFlags.reset(CHN_ADLIB);
chn.dwFlags.set(CHN_NOTEFADE);
chn.nFadeOutVol = 0;
} else if(m_playBehaviour[kOPLFlexibleNoteOff] && chn.dwFlags[CHN_NOTEFADE] && chn.nFadeOutVol == 0)
{
m_opl->NoteCut(nChn);
chn.dwFlags.reset(CHN_ADLIB);
}
}
}
// Increment envelope positions
if(pIns != nullptr && !m_playBehaviour[kITEnvelopePositionHandling])
{
// In IT and FT2 compatible mode, envelope positions are updated above.
// Test cases: s77.it, EnvLoops.xm
IncrementEnvelopePositions(chn);
}
// Volume ramping
chn.dwFlags.set(CHN_VOLUMERAMP, (chn.nRealVolume | chn.rightVol | chn.leftVol) != 0 && !chn.dwFlags[CHN_ADLIB]);
constexpr uint8 VUMETER_DECAY = 4;
chn.nLeftVU = (chn.nLeftVU > VUMETER_DECAY) ? (chn.nLeftVU - VUMETER_DECAY) : 0;
chn.nRightVU = (chn.nRightVU > VUMETER_DECAY) ? (chn.nRightVU - VUMETER_DECAY) : 0;
chn.newLeftVol = chn.newRightVol = 0;
chn.pCurrentSample = (chn.pModSample && chn.pModSample->HasSampleData() && chn.nLength && chn.IsSamplePlaying()) ? chn.pModSample->samplev() : nullptr;
if(chn.pCurrentSample || (chn.HasMIDIOutput() && !chn.dwFlags[CHN_KEYOFF | CHN_NOTEFADE]))
{
// Update VU-Meter (nRealVolume is 14-bit)
uint32 vul = (chn.nRealVolume * (256-chn.nRealPan)) / (1 << 14);
if (vul > 127) vul = 127;
if (chn.nLeftVU > 127) chn.nLeftVU = (uint8)vul;
vul /= 2;
if (chn.nLeftVU < vul) chn.nLeftVU = (uint8)vul;
uint32 vur = (chn.nRealVolume * chn.nRealPan) / (1 << 14);
if (vur > 127) vur = 127;
if (chn.nRightVU > 127) chn.nRightVU = (uint8)vur;
vur /= 2;
if (chn.nRightVU < vur) chn.nRightVU = (uint8)vur;
} else
{
// Note change but no sample
if (chn.nLeftVU > 128) chn.nLeftVU = 0;
if (chn.nRightVU > 128) chn.nRightVU = 0;
}
if (chn.pCurrentSample)
{
#ifdef MODPLUG_TRACKER
const uint32 kChnMasterVol = chn.dwFlags[CHN_EXTRALOUD] ? (uint32)m_PlayConfig.getNormalSamplePreAmp() : nMasterVol;
#else
const uint32 kChnMasterVol = nMasterVol;
#endif // MODPLUG_TRACKER
// Adjusting volumes
{
int32 pan = (m_MixerSettings.gnChannels >= 2) ? Clamp(chn.nRealPan, 0, 256) : 128;
int32 realvol;
if(m_PlayConfig.getUseGlobalPreAmp())
{
realvol = (chn.nRealVolume * kChnMasterVol) / 128;
} else
{
// Extra attenuation required here if we're bypassing pre-amp.
realvol = (chn.nRealVolume * kChnMasterVol) / 256;
}
const PanningMode panningMode = m_PlayConfig.getPanningMode();
if(panningMode == PanningMode::SoftPanning || (panningMode == PanningMode::Undetermined && (m_MixerSettings.MixerFlags & SNDMIX_SOFTPANNING)))
{
if(pan < 128)
{
chn.newLeftVol = (realvol * 128) / 256;
chn.newRightVol = (realvol * pan) / 256;
} else
{
chn.newLeftVol = (realvol * (256 - pan)) / 256;
chn.newRightVol = (realvol * 128) / 256;
}
} else if(panningMode == PanningMode::FT2Panning)
{
// FT2 uses square root panning. There is a 257-entry LUT for this,
// but FT2's internal panning ranges from 0 to 255 only, meaning that
// you can never truly achieve 100% right panning in FT2, only 100% left.
// Test case: FT2PanLaw.xm
LimitMax(pan, 255);
const int panL = pan > 0 ? XMPanningTable[256 - pan] : 65536;
const int panR = XMPanningTable[pan];
chn.newLeftVol = (realvol * panL) / 65536;
chn.newRightVol = (realvol * panR) / 65536;
} else
{
chn.newLeftVol = (realvol * (256 - pan)) / 256;
chn.newRightVol = (realvol * pan) / 256;
}
}
// Clipping volumes
//if (chn.nNewRightVol > 0xFFFF) chn.nNewRightVol = 0xFFFF;
//if (chn.nNewLeftVol > 0xFFFF) chn.nNewLeftVol = 0xFFFF;
if(chn.pModInstrument && Resampling::IsKnownMode(chn.pModInstrument->resampling))
{
// For defined resampling modes, use per-instrument resampling mode if set
chn.resamplingMode = chn.pModInstrument->resampling;
} else if(Resampling::IsKnownMode(m_nResampling))
{
chn.resamplingMode = m_nResampling;
} else if(m_SongFlags[SONG_ISAMIGA] && m_Resampler.m_Settings.emulateAmiga != Resampling::AmigaFilter::Off)
{
// Enforce Amiga resampler for Amiga modules
chn.resamplingMode = SRCMODE_AMIGA;
} else
{
// Default to global mixer settings
chn.resamplingMode = m_Resampler.m_Settings.SrcMode;
}
if(chn.increment.IsUnity() && !(chn.dwFlags[CHN_VIBRATO] || chn.nAutoVibDepth || chn.resamplingMode == SRCMODE_AMIGA))
{
// Exact sample rate match, do not interpolate at all
// - unless vibrato is applied, because in this case the constant enabling and disabling
// of resampling can introduce clicks (this is easily observable with a sine sample
// played at the mix rate).
chn.resamplingMode = SRCMODE_NEAREST;
}
const int extraAttenuation = m_PlayConfig.getExtraSampleAttenuation();
chn.newLeftVol /= (1 << extraAttenuation);
chn.newRightVol /= (1 << extraAttenuation);
// Dolby Pro-Logic Surround
if(chn.dwFlags[CHN_SURROUND] && m_MixerSettings.gnChannels == 2) chn.newRightVol = -chn.newRightVol;
// Checking Ping-Pong Loops
if(chn.dwFlags[CHN_PINGPONGFLAG]) chn.increment.Negate();
// Setting up volume ramp
ProcessRamping(chn);
// Adding the channel in the channel list
if(!chn.dwFlags[CHN_ADLIB])
{
m_PlayState.ChnMix[m_nMixChannels++] = nChn;
}
} else
{
chn.rightVol = chn.leftVol = 0;
chn.nLength = 0;
// Put the channel back into the mixer for end-of-sample pop reduction
if(chn.nLOfs || chn.nROfs)
m_PlayState.ChnMix[m_nMixChannels++] = nChn;
}
chn.dwOldFlags = chn.dwFlags;
}
// If there are more channels being mixed than allowed, order them by volume and discard the most quiet ones
if(m_nMixChannels >= m_MixerSettings.m_nMaxMixChannels)
{
std::partial_sort(std::begin(m_PlayState.ChnMix), std::begin(m_PlayState.ChnMix) + m_MixerSettings.m_nMaxMixChannels, std::begin(m_PlayState.ChnMix) + m_nMixChannels,
[this](CHANNELINDEX i, CHANNELINDEX j) { return (m_PlayState.Chn[i].nRealVolume > m_PlayState.Chn[j].nRealVolume); });
}
return true;
}
void CSoundFile::ProcessMacroOnChannel(CHANNELINDEX nChn)
{
ModChannel &chn = m_PlayState.Chn[nChn];
if(nChn < GetNumChannels())
{
// TODO evaluate per-plugin macros here
//ProcessMIDIMacro(m_PlayState, nChn, false, m_MidiCfg.Global[MIDIOUT_PAN]);
//ProcessMIDIMacro(m_PlayState, nChn, false, m_MidiCfg.Global[MIDIOUT_VOLUME]);
if((chn.rowCommand.command == CMD_MIDI && m_SongFlags[SONG_FIRSTTICK]) || chn.rowCommand.command == CMD_SMOOTHMIDI)
{
if(chn.rowCommand.param < 0x80)
ProcessMIDIMacro(m_PlayState, nChn, (chn.rowCommand.command == CMD_SMOOTHMIDI), m_MidiCfg.SFx[chn.nActiveMacro], chn.rowCommand.param);
else
ProcessMIDIMacro(m_PlayState, nChn, (chn.rowCommand.command == CMD_SMOOTHMIDI), m_MidiCfg.Zxx[chn.rowCommand.param & 0x7F], chn.rowCommand.param);
}
}
}
#ifndef NO_PLUGINS
void CSoundFile::ProcessMidiOut(CHANNELINDEX nChn)
{
ModChannel &chn = m_PlayState.Chn[nChn];
// Do we need to process MIDI?
// For now there is no difference between mute and sync mute with VSTis.
if(chn.dwFlags[CHN_MUTE | CHN_SYNCMUTE] || !chn.HasMIDIOutput()) return;
// Get instrument info and plugin reference
const ModInstrument *pIns = chn.pModInstrument; // Can't be nullptr at this point, as we have valid MIDI output.
// No instrument or muted instrument?
if(pIns->dwFlags[INS_MUTE])
{
return;
}
// Check instrument plugins
const PLUGINDEX nPlugin = GetBestPlugin(m_PlayState, nChn, PrioritiseInstrument, RespectMutes);
IMixPlugin *pPlugin = nullptr;
if(nPlugin > 0 && nPlugin <= MAX_MIXPLUGINS)
{
pPlugin = m_MixPlugins[nPlugin - 1].pMixPlugin;
}
// Couldn't find a valid plugin
if(pPlugin == nullptr) return;
const ModCommand::NOTE note = chn.rowCommand.note;
// Check for volume commands
uint8 vol = 0xFF;
if(chn.rowCommand.volcmd == VOLCMD_VOLUME)
{
vol = std::min(chn.rowCommand.vol, uint8(64));
} else if(chn.rowCommand.command == CMD_VOLUME)
{
vol = std::min(chn.rowCommand.param, uint8(64));
}
const bool hasVolCommand = (vol != 0xFF);
if(m_playBehaviour[kMIDICCBugEmulation])
{
if(note != NOTE_NONE)
{
ModCommand::NOTE realNote = note;
if(ModCommand::IsNote(note))
realNote = pIns->NoteMap[note - NOTE_MIN];
SendMIDINote(nChn, realNote, static_cast<uint16>(chn.nVolume));
} else if(hasVolCommand)
{
pPlugin->MidiCC(MIDIEvents::MIDICC_Volume_Fine, vol, nChn);
}
return;
}
const uint32 defaultVolume = pIns->nGlobalVol;
//If new note, determine notevelocity to use.
if(note != NOTE_NONE)
{
int32 velocity = static_cast<int32>(4 * defaultVolume);
switch(pIns->pluginVelocityHandling)
{
case PLUGIN_VELOCITYHANDLING_CHANNEL:
velocity = chn.nVolume;
break;
default:
break;
}
int32 swing = chn.nVolSwing;
if(m_playBehaviour[kITSwingBehaviour]) swing *= 4;
velocity += swing;
Limit(velocity, 0, 256);
ModCommand::NOTE realNote = note;
if(ModCommand::IsNote(note))
realNote = pIns->NoteMap[note - NOTE_MIN];
// Experimental VST panning
//ProcessMIDIMacro(nChn, false, m_MidiCfg.Global[MIDIOUT_PAN], 0, nPlugin);
SendMIDINote(nChn, realNote, static_cast<uint16>(velocity));
}
const bool processVolumeAlsoOnNote = (pIns->pluginVelocityHandling == PLUGIN_VELOCITYHANDLING_VOLUME);
const bool hasNote = m_playBehaviour[kMIDIVolumeOnNoteOffBug] ? (note != NOTE_NONE) : ModCommand::IsNote(note);
if((hasVolCommand && !hasNote) || (hasNote && processVolumeAlsoOnNote))
{
switch(pIns->pluginVolumeHandling)
{
case PLUGIN_VOLUMEHANDLING_DRYWET:
if(hasVolCommand) pPlugin->SetDryRatio(1.0f - (2 * vol) / 127.0f);
else pPlugin->SetDryRatio(1.0f - (2 * defaultVolume) / 127.0f);
break;
case PLUGIN_VOLUMEHANDLING_MIDI:
if(hasVolCommand) pPlugin->MidiCC(MIDIEvents::MIDICC_Volume_Coarse, std::min(uint8(127), static_cast<uint8>(2 * vol)), nChn);
else pPlugin->MidiCC(MIDIEvents::MIDICC_Volume_Coarse, static_cast<uint8>(std::min(uint32(127), static_cast<uint32>(2 * defaultVolume))), nChn);
break;
default:
break;
}
}
}
#endif // NO_PLUGINS
template<int channels>
MPT_FORCEINLINE void ApplyGlobalVolumeWithRamping(int32 *SoundBuffer, int32 *RearBuffer, int32 lCount, int32 m_nGlobalVolume, int32 step, int32 &m_nSamplesToGlobalVolRampDest, int32 &m_lHighResRampingGlobalVolume)
{
const bool isStereo = (channels >= 2);
const bool hasRear = (channels >= 4);
for(int pos = 0; pos < lCount; ++pos)
{
if(m_nSamplesToGlobalVolRampDest > 0)
{
// Ramping required
m_lHighResRampingGlobalVolume += step;
SoundBuffer[0] = Util::muldiv(SoundBuffer[0], m_lHighResRampingGlobalVolume, MAX_GLOBAL_VOLUME << VOLUMERAMPPRECISION);
if constexpr(isStereo) SoundBuffer[1] = Util::muldiv(SoundBuffer[1], m_lHighResRampingGlobalVolume, MAX_GLOBAL_VOLUME << VOLUMERAMPPRECISION);
if constexpr(hasRear) RearBuffer[0] = Util::muldiv(RearBuffer[0] , m_lHighResRampingGlobalVolume, MAX_GLOBAL_VOLUME << VOLUMERAMPPRECISION); else MPT_UNUSED_VARIABLE(RearBuffer);
if constexpr(hasRear) RearBuffer[1] = Util::muldiv(RearBuffer[1] , m_lHighResRampingGlobalVolume, MAX_GLOBAL_VOLUME << VOLUMERAMPPRECISION); else MPT_UNUSED_VARIABLE(RearBuffer);
m_nSamplesToGlobalVolRampDest--;
} else
{
SoundBuffer[0] = Util::muldiv(SoundBuffer[0], m_nGlobalVolume, MAX_GLOBAL_VOLUME);
if constexpr(isStereo) SoundBuffer[1] = Util::muldiv(SoundBuffer[1], m_nGlobalVolume, MAX_GLOBAL_VOLUME);
if constexpr(hasRear) RearBuffer[0] = Util::muldiv(RearBuffer[0] , m_nGlobalVolume, MAX_GLOBAL_VOLUME); else MPT_UNUSED_VARIABLE(RearBuffer);
if constexpr(hasRear) RearBuffer[1] = Util::muldiv(RearBuffer[1] , m_nGlobalVolume, MAX_GLOBAL_VOLUME); else MPT_UNUSED_VARIABLE(RearBuffer);
m_lHighResRampingGlobalVolume = m_nGlobalVolume << VOLUMERAMPPRECISION;
}
SoundBuffer += isStereo ? 2 : 1;
if constexpr(hasRear) RearBuffer += 2;
}
}
void CSoundFile::ProcessGlobalVolume(long lCount)
{
// should we ramp?
if(IsGlobalVolumeUnset())
{
// do not ramp if no global volume was set before (which is the case at song start), to prevent audible glitches when default volume is > 0 and it is set to 0 in the first row
m_PlayState.m_nGlobalVolumeDestination = m_PlayState.m_nGlobalVolume;
m_PlayState.m_nSamplesToGlobalVolRampDest = 0;
m_PlayState.m_nGlobalVolumeRampAmount = 0;
} else if(m_PlayState.m_nGlobalVolumeDestination != m_PlayState.m_nGlobalVolume)
{
// User has provided new global volume
// m_nGlobalVolume: the last global volume which got set e.g. by a pattern command
// m_nGlobalVolumeDestination: the current target of the ramping algorithm
const bool rampUp = m_PlayState.m_nGlobalVolume > m_PlayState.m_nGlobalVolumeDestination;
m_PlayState.m_nGlobalVolumeDestination = m_PlayState.m_nGlobalVolume;
m_PlayState.m_nSamplesToGlobalVolRampDest = m_PlayState.m_nGlobalVolumeRampAmount = rampUp ? m_MixerSettings.GetVolumeRampUpSamples() : m_MixerSettings.GetVolumeRampDownSamples();
}
// calculate ramping step
int32 step = 0;
if (m_PlayState.m_nSamplesToGlobalVolRampDest > 0)
{
// Still some ramping left to do.
int32 highResGlobalVolumeDestination = static_cast<int32>(m_PlayState.m_nGlobalVolumeDestination) << VOLUMERAMPPRECISION;
const long delta = highResGlobalVolumeDestination - m_PlayState.m_lHighResRampingGlobalVolume;
step = delta / static_cast<long>(m_PlayState.m_nSamplesToGlobalVolRampDest);
if(m_nMixLevels == MixLevels::v1_17RC2)
{
// Define max step size as some factor of user defined ramping value: the lower the value, the more likely the click.
// If step is too big (might cause click), extend ramp length.
// Warning: This increases the volume ramp length by EXTREME amounts (factors of 100 are easily reachable)
// compared to the user-defined setting, so this really should not be used!
int32 maxStep = std::max(int32(50), static_cast<int32>((10000 / (m_PlayState.m_nGlobalVolumeRampAmount + 1))));
while(std::abs(step) > maxStep)
{
m_PlayState.m_nSamplesToGlobalVolRampDest += m_PlayState.m_nGlobalVolumeRampAmount;
step = delta / static_cast<int32>(m_PlayState.m_nSamplesToGlobalVolRampDest);
}
}
}
// apply volume and ramping
if(m_MixerSettings.gnChannels == 1)
{
ApplyGlobalVolumeWithRamping<1>(MixSoundBuffer, MixRearBuffer, lCount, m_PlayState.m_nGlobalVolume, step, m_PlayState.m_nSamplesToGlobalVolRampDest, m_PlayState.m_lHighResRampingGlobalVolume);
} else if(m_MixerSettings.gnChannels == 2)
{
ApplyGlobalVolumeWithRamping<2>(MixSoundBuffer, MixRearBuffer, lCount, m_PlayState.m_nGlobalVolume, step, m_PlayState.m_nSamplesToGlobalVolRampDest, m_PlayState.m_lHighResRampingGlobalVolume);
} else if(m_MixerSettings.gnChannels == 4)
{
ApplyGlobalVolumeWithRamping<4>(MixSoundBuffer, MixRearBuffer, lCount, m_PlayState.m_nGlobalVolume, step, m_PlayState.m_nSamplesToGlobalVolRampDest, m_PlayState.m_lHighResRampingGlobalVolume);
}
}
void CSoundFile::ProcessStereoSeparation(long countChunk)
{
ApplyStereoSeparation(MixSoundBuffer, MixRearBuffer, m_MixerSettings.gnChannels, countChunk, m_MixerSettings.m_nStereoSeparation);
}
OPENMPT_NAMESPACE_END