winamp/Src/external_dependencies/openmpt-trunk/soundlib/plugins/LFOPlugin.cpp

522 lines
12 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
/*
* LFOPlugin.cpp
* -------------
* Purpose: Plugin for automating other plugins' parameters
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#ifndef NO_PLUGINS
#include "LFOPlugin.h"
#include "../Sndfile.h"
#include "../../common/FileReader.h"
#ifdef MODPLUG_TRACKER
#include "../../mptrack/plugins/LFOPluginEditor.h"
#endif // MODPLUG_TRACKER
#include "mpt/base/numbers.hpp"
OPENMPT_NAMESPACE_BEGIN
IMixPlugin* LFOPlugin::Create(VSTPluginLib &factory, CSoundFile &sndFile, SNDMIXPLUGIN *mixStruct)
{
return new (std::nothrow) LFOPlugin(factory, sndFile, mixStruct);
}
LFOPlugin::LFOPlugin(VSTPluginLib &factory, CSoundFile &sndFile, SNDMIXPLUGIN *mixStruct)
: IMixPlugin(factory, sndFile, mixStruct)
, m_PRNG(mpt::make_prng<mpt::fast_prng>(mpt::global_prng()))
{
RecalculateFrequency();
RecalculateIncrement();
m_mixBuffer.Initialize(2, 2);
InsertIntoFactoryList();
}
// Processing (we do not process audio, just send out parameters)
void LFOPlugin::Process(float *pOutL, float *pOutR, uint32 numFrames)
{
if(!m_bypassed)
{
ResetSilence();
if(m_tempoSync)
{
double tempo = m_SndFile.GetCurrentBPM();
if(tempo != m_tempo)
{
m_tempo = tempo;
RecalculateIncrement();
}
}
if(m_oneshot)
{
LimitMax(m_phase, 1.0);
} else
{
int intPhase = static_cast<int>(m_phase);
if(intPhase > 0 && (m_waveForm == kSHNoise || m_waveForm == kSmoothNoise))
{
// Phase wrap-around happened
NextRandom();
}
m_phase -= intPhase;
}
double value = 0;
switch(m_waveForm)
{
case kSine:
value = std::sin(m_phase * (2.0 * mpt::numbers::pi));
break;
case kTriangle:
value = 1.0 - 4.0 * std::abs(m_phase - 0.5);
break;
case kSaw:
value = 2.0 * m_phase - 1.0;
break;
case kSquare:
value = m_phase < 0.5 ? -1.0 : 1.0;
break;
case kSHNoise:
value = m_random;
break;
case kSmoothNoise:
value = m_phase * m_phase * m_phase * (m_phase * (m_phase * 6 - 15) + 10); // Smootherstep
value = m_nextRandom * value + m_random * (1.0 - value);
break;
default:
break;
}
if(m_polarity)
value = -value;
// Transform value from -1...+1 to 0...1 range and apply offset/amplitude
value = value * m_amplitude + m_offset;
Limit(value, 0.0, 1.0);
IMixPlugin *plugin = GetOutputPlugin();
if(plugin != nullptr)
{
if(m_outputToCC)
{
plugin->MidiSend(MIDIEvents::CC(static_cast<MIDIEvents::MidiCC>(m_outputParam & 0x7F), static_cast<uint8>((m_outputParam >> 8) & 0x0F), mpt::saturate_round<uint8>(value * 127.0f)));
} else
{
plugin->SetParameter(m_outputParam, static_cast<PlugParamValue>(value));
}
}
m_phase += m_increment * numFrames;
}
ProcessMixOps(pOutL, pOutR, m_mixBuffer.GetInputBuffer(0), m_mixBuffer.GetInputBuffer(1), numFrames);
}
PlugParamValue LFOPlugin::GetParameter(PlugParamIndex index)
{
switch(index)
{
case kAmplitude: return m_amplitude;
case kOffset: return m_offset;
case kFrequency: return m_frequency;
case kTempoSync: return m_tempoSync ? 1.0f : 0.0f;
case kWaveform: return WaveformToParam(m_waveForm);
case kPolarity: return m_polarity ? 1.0f : 0.0f;
case kBypassed: return m_bypassed ? 1.0f : 0.0f;
case kLoopMode: return m_oneshot ? 1.0f : 0.0f;
default: return 0;
}
}
void LFOPlugin::SetParameter(PlugParamIndex index, PlugParamValue value)
{
ResetSilence();
value = mpt::safe_clamp(value, 0.0f, 1.0f);
switch(index)
{
case kAmplitude: m_amplitude = value; break;
case kOffset: m_offset = value; break;
case kFrequency:
m_frequency = value;
RecalculateFrequency();
break;
case kTempoSync:
m_tempoSync = (value >= 0.5f);
RecalculateFrequency();
break;
case kWaveform:
m_waveForm = ParamToWaveform(value);
break;
case kPolarity: m_polarity = (value >= 0.5f); break;
case kBypassed: m_bypassed = (value >= 0.5f); break;
case kLoopMode: m_oneshot = (value >= 0.5f); break;
case kCurrentPhase:
if(value == 0)
{
// Enforce next random value for random LFOs
NextRandom();
}
m_phase = value;
return;
default: return;
}
#ifdef MODPLUG_TRACKER
if(GetEditor() != nullptr)
{
GetEditor()->PostMessage(WM_PARAM_UDPATE, GetSlot(), index);
}
#endif
}
void LFOPlugin::Resume()
{
m_isResumed = true;
RecalculateIncrement();
NextRandom();
PositionChanged();
}
void LFOPlugin::PositionChanged()
{
// TODO Changing tempo (with tempo sync enabled), parameter automation over time and setting the LFO phase manually is not considered here.
m_phase = m_increment * m_SndFile.GetTotalSampleCount();
m_phase -= static_cast<int64>(m_phase);
}
bool LFOPlugin::MidiSend(uint32 midiCode)
{
if(IMixPlugin *plugin = GetOutputPlugin())
return plugin->MidiSend(midiCode);
else
return true;
}
bool LFOPlugin::MidiSysexSend(mpt::const_byte_span sysex)
{
if(IMixPlugin *plugin = GetOutputPlugin())
return plugin->MidiSysexSend(sysex);
else
return true;
}
void LFOPlugin::MidiCC(MIDIEvents::MidiCC nController, uint8 nParam, CHANNELINDEX trackChannel)
{
if(IMixPlugin *plugin = GetOutputPlugin())
{
plugin->MidiCC(nController, nParam, trackChannel);
}
}
void LFOPlugin::MidiPitchBend(int32 increment, int8 pwd, CHANNELINDEX trackChannel)
{
if(IMixPlugin *plugin = GetOutputPlugin())
{
plugin->MidiPitchBend(increment, pwd, trackChannel);
}
}
void LFOPlugin::MidiVibrato(int32 depth, int8 pwd, CHANNELINDEX trackChannel)
{
if(IMixPlugin *plugin = GetOutputPlugin())
{
plugin->MidiVibrato(depth, pwd, trackChannel);
}
}
void LFOPlugin::MidiCommand(const ModInstrument &instr, uint16 note, uint16 vol, CHANNELINDEX trackChannel)
{
if(ModCommand::IsNote(static_cast<ModCommand::NOTE>(note)) && vol > 0)
{
SetParameter(kCurrentPhase, 0);
}
if(IMixPlugin *plugin = GetOutputPlugin())
{
plugin->MidiCommand(instr, note, vol, trackChannel);
}
}
void LFOPlugin::HardAllNotesOff()
{
if(IMixPlugin *plugin = GetOutputPlugin())
{
plugin->HardAllNotesOff();
}
}
bool LFOPlugin::IsNotePlaying(uint8 note, CHANNELINDEX trackerChn)
{
if(IMixPlugin *plugin = GetOutputPlugin())
return plugin->IsNotePlaying(note, trackerChn);
else
return false;
}
void LFOPlugin::SaveAllParameters()
{
auto chunk = GetChunk(false);
if(chunk.empty())
return;
m_pMixStruct->defaultProgram = -1;
m_pMixStruct->pluginData.assign(chunk.begin(), chunk.end());
}
void LFOPlugin::RestoreAllParameters(int32 /*program*/)
{
SetChunk(mpt::as_span(m_pMixStruct->pluginData), false);
}
struct PluginData
{
char magic[4];
uint32le version;
uint32le amplitude; // float
uint32le offset; // float
uint32le frequency; // float
uint32le waveForm;
uint32le outputParam;
uint8le tempoSync;
uint8le polarity;
uint8le bypassed;
uint8le outputToCC;
uint8le loopMode;
};
MPT_BINARY_STRUCT(PluginData, 33)
IMixPlugin::ChunkData LFOPlugin::GetChunk(bool)
{
PluginData chunk;
memcpy(chunk.magic, "LFO ", 4);
chunk.version = 0;
chunk.amplitude = IEEE754binary32LE(m_amplitude).GetInt32();
chunk.offset = IEEE754binary32LE(m_offset).GetInt32();
chunk.frequency = IEEE754binary32LE(m_frequency).GetInt32();
chunk.waveForm = m_waveForm;
chunk.outputParam = m_outputParam;
chunk.tempoSync = m_tempoSync ? 1 : 0;
chunk.polarity = m_polarity ? 1 : 0;
chunk.bypassed = m_bypassed ? 1 : 0;
chunk.outputToCC = m_outputToCC ? 1 : 0;
chunk.loopMode = m_oneshot ? 1 : 0;
m_chunkData.resize(sizeof(chunk));
memcpy(m_chunkData.data(), &chunk, sizeof(chunk));
return mpt::as_span(m_chunkData);
}
void LFOPlugin::SetChunk(const ChunkData &chunk, bool)
{
FileReader file(chunk);
PluginData data;
if(file.ReadStructPartial(data, file.BytesLeft())
&& !memcmp(data.magic, "LFO ", 4)
&& data.version == 0)
{
const float amplitude = IEEE754binary32LE().SetInt32(data.amplitude);
m_amplitude = mpt::safe_clamp(amplitude, 0.0f, 1.0f);
const float offset = IEEE754binary32LE().SetInt32(data.offset);
m_offset = mpt::safe_clamp(offset, 0.0f, 1.0f);
const float frequency = IEEE754binary32LE().SetInt32(data.frequency);
m_frequency = mpt::safe_clamp(frequency, 0.0f, 1.0f);
if(data.waveForm < kNumWaveforms)
m_waveForm = static_cast<LFOWaveform>(data.waveForm.get());
m_outputParam = data.outputParam;
m_tempoSync = data.tempoSync != 0;
m_polarity = data.polarity != 0;
m_bypassed = data.bypassed != 0;
m_outputToCC = data.outputToCC != 0;
m_oneshot = data.loopMode != 0;
RecalculateFrequency();
}
}
#ifdef MODPLUG_TRACKER
std::pair<PlugParamValue, PlugParamValue> LFOPlugin::GetParamUIRange(PlugParamIndex param)
{
if(param == kWaveform)
return {0.0f, WaveformToParam(static_cast<LFOWaveform>(kNumWaveforms - 1))};
else
return {0.0f, 1.0f};
}
CString LFOPlugin::GetParamName(PlugParamIndex param)
{
switch(param)
{
case kAmplitude: return _T("Amplitude");
case kOffset: return _T("Offset");
case kFrequency: return _T("Frequency");
case kTempoSync: return _T("Tempo Sync");
case kWaveform: return _T("Waveform");
case kPolarity: return _T("Polarity");
case kBypassed: return _T("Bypassed");
case kLoopMode: return _T("Loop Mode");
case kCurrentPhase: return _T("Set LFO Phase");
}
return CString();
}
CString LFOPlugin::GetParamLabel(PlugParamIndex param)
{
if(param == kFrequency)
{
if(m_tempoSync && m_computedFrequency > 0.0 && m_computedFrequency < 1.0)
return _T("Beats Per Cycle");
else if(m_tempoSync)
return _T("Cycles Per Beat");
else
return _T("Hz");
}
return CString();
}
CString LFOPlugin::GetParamDisplay(PlugParamIndex param)
{
CString s;
if(param == kPolarity)
{
return m_polarity ? _T("Inverted") : _T("Normal");
} else if(param == kTempoSync)
{
return m_tempoSync ? _T("Yes") : _T("No");
} else if(param == kBypassed)
{
return m_bypassed ? _T("Yes") : _T("No");
} else if(param == kWaveform)
{
static constexpr const TCHAR * const waveforms[] = { _T("Sine"), _T("Triangle"), _T("Saw"), _T("Square"), _T("Noise"), _T("Smoothed Noise") };
if(m_waveForm < static_cast<int>(std::size(waveforms)))
return waveforms[m_waveForm];
} else if(param == kLoopMode)
{
return m_oneshot ? _T("One-Shot") : _T("Looped");
} else if(param == kCurrentPhase)
{
return _T("Write-Only");
} else if(param < kLFONumParameters)
{
auto val = GetParameter(param);
if(param == kOffset)
val = 2.0f * val - 1.0f;
if(param == kFrequency)
{
val = static_cast<PlugParamValue>(m_computedFrequency);
if(m_tempoSync && val > 0.0f && val < 1.0f)
val = static_cast<PlugParamValue>(1.0 / m_computedFrequency);
}
s.Format(_T("%.3f"), val);
}
return s;
}
CAbstractVstEditor *LFOPlugin::OpenEditor()
{
try
{
return new LFOPluginEditor(*this);
} catch(mpt::out_of_memory e)
{
mpt::delete_out_of_memory(e);
return nullptr;
}
}
#endif // MODPLUG_TRACKER
void LFOPlugin::NextRandom()
{
m_random = m_nextRandom;
m_nextRandom = mpt::random<int32>(m_PRNG) / static_cast<float>(int32_min);
}
void LFOPlugin::RecalculateFrequency()
{
m_computedFrequency = 0.25 * std::pow(2.0, m_frequency * 8.0) - 0.25;
if(m_tempoSync)
{
if(m_computedFrequency > 0.00045)
{
double freqLog = std::log(m_computedFrequency) / mpt::numbers::ln2;
double freqFrac = freqLog - std::floor(freqLog);
freqLog -= freqFrac;
// Lock to powers of two and 1.5 times or 1.333333... times the powers of two
if(freqFrac < 0.20751874963942190927313052802609)
freqFrac = 0.0;
else if(freqFrac < 0.5)
freqFrac = 0.41503749927884381854626105605218;
else if(freqFrac < 0.79248125036057809072686947197391)
freqFrac = 0.58496250072115618145373894394782;
else
freqFrac = 1.0;
m_computedFrequency = std::pow(2.0, freqLog + freqFrac) * 0.5;
} else
{
m_computedFrequency = 0;
}
}
RecalculateIncrement();
}
void LFOPlugin::RecalculateIncrement()
{
m_increment = m_computedFrequency / m_SndFile.GetSampleRate();
if(m_tempoSync)
{
m_increment *= m_tempo / 60.0;
}
}
IMixPlugin *LFOPlugin::GetOutputPlugin() const
{
PLUGINDEX outPlug = m_pMixStruct->GetOutputPlugin();
if(outPlug > m_nSlot && outPlug < MAX_MIXPLUGINS)
return m_SndFile.m_MixPlugins[outPlug].pMixPlugin;
else
return nullptr;
}
OPENMPT_NAMESPACE_END
#else
MPT_MSVC_WORKAROUND_LNK4221(LFOPlugin)
#endif // !NO_PLUGINS