path: root/Src/external_dependencies/openmpt-trunk/mptrack/Vstplug.cpp

/*
 * Vstplug.cpp
 * -----------
 * Purpose: VST Plugin handling / processing
 * Notes  : (currently none)
 * Authors: OpenMPT Devs
 * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
 */


#include "stdafx.h"

#ifdef MPT_WITH_VST

#include "Vstplug.h"
#ifdef MODPLUG_TRACKER
#include "Moddoc.h"
#include "Mainfrm.h"
#include "AbstractVstEditor.h"
#include "VSTEditor.h"
#include "DefaultVstEditor.h"
#include "ExceptionHandler.h"
#endif // MODPLUG_TRACKER
#include "../soundlib/Sndfile.h"
#include "../soundlib/MIDIEvents.h"
#include "MIDIMappingDialog.h"
#include "../common/mptStringBuffer.h"
#include "FileDialog.h"
#include "../pluginBridge/BridgeWrapper.h"
#include "../pluginBridge/BridgeOpCodes.h"
#include "../soundlib/plugins/OpCodes.h"
#include "../soundlib/plugins/PluginManager.h"
#include "../misc/mptOSException.h"

using namespace Vst;
DECLARE_FLAGSET(Vst::VstTimeInfoFlags)

OPENMPT_NAMESPACE_BEGIN

static VstTimeInfo g_timeInfoFallback = { 0 };

#ifdef MPT_ALL_LOGGING
#define VST_LOG
#endif


using VstCrash = Windows::SEH::Code;


bool CVstPlugin::MaskCrashes() noexcept
{
	return m_maskCrashes;
}


template <typename Tfn>
DWORD CVstPlugin::SETryOrError(bool maskCrashes, Tfn fn)
{
	DWORD exception = 0;
	if(maskCrashes)
	{
		exception = Windows::SEH::TryOrError(fn);
		if(exception)
		{
			ExceptionHandler::TaintProcess(ExceptionHandler::TaintReason::Plugin);
		}
	} else
	{
		fn();
	}
	return exception;
}


template <typename Tfn>
DWORD CVstPlugin::SETryOrError(Tfn fn)
{
	DWORD exception = 0;
	if(MaskCrashes())
	{
		exception = Windows::SEH::TryOrError(fn);
		if(exception)
		{
			ExceptionHandler::TaintProcess(ExceptionHandler::TaintReason::Plugin);
		}
	} else
	{
#ifdef MODPLUG_TRACKER
		ExceptionHandler::ContextSetter ectxguard{&m_Ectx};
#endif // MODPLUG_TRACKER
		fn();
	}
	return exception;
}


AEffect *CVstPlugin::LoadPlugin(bool maskCrashes, VSTPluginLib &plugin, HMODULE &library, BridgeMode bridgeMode)
{
	const mpt::PathString &pluginPath = plugin.dllPath;

	AEffect *effect = nullptr;
	library = nullptr;

	const bool isNative = plugin.IsNative(false);
	if(bridgeMode != BridgeMode::Automatic || plugin.useBridge || !isNative)
	{
		if(bridgeMode == BridgeMode::DetectRequiredBridgeMode)
		{
			// First try modern bridge, then legacy bridge
			plugin.modernBridge = true;
			try
			{
				effect = BridgeWrapper::Create(plugin, false);
				if(effect != nullptr)
				{
					return effect;
				}
			} catch(BridgeWrapper::BridgeNotFoundException &)
			{
			} catch(BridgeWrapper::BridgeException &)
			{
			}
			// Retry with legacy bridge
			plugin.useBridge = true;
			plugin.modernBridge = false;
		}

		try
		{
			effect = BridgeWrapper::Create(plugin, bridgeMode == BridgeMode::DetectRequiredBridgeMode);
			if(effect != nullptr)
			{
				return effect;
			}
		} catch(BridgeWrapper::BridgeNotFoundException &)
		{
			// Try normal loading
			if(!isNative)
			{
				Reporting::Error("Could not locate the plugin bridge executable, which is required for running non-native plugins.", "OpenMPT Plugin Bridge");
				return nullptr;
			}
		} catch(BridgeWrapper::BridgeException &e)
		{
			// If there was some error, don't try normal loading as well... unless the user really wants it.
			if(isNative)
			{
				const CString msg =
					MPT_CFORMAT("The following error occurred while trying to load\n{}\n\n{}\n\nDo you want to try to load the plugin natively?")
					(plugin.dllPath, mpt::get_exception_text<mpt::ustring>(e));
				if(Reporting::Confirm(msg, _T("OpenMPT Plugin Bridge")) == cnfNo)
				{
					return nullptr;
				}
			} else
			{
				Reporting::Error(mpt::get_exception_text<mpt::ustring>(e), "OpenMPT Plugin Bridge");
				return nullptr;
			}
		}
		// If plugin was marked to use the plugin bridge but this somehow doesn't work (e.g. because the bridge is missing),
		// disable the plugin bridge for this plugin.
		plugin.useBridge = false;
		plugin.modernBridge = true;
	}

	{
#ifdef MODPLUG_TRACKER
		ExceptionHandler::Context ectx{ MPT_UFORMAT("VST Plugin: {}")(plugin.dllPath.ToUnicode()) };
		ExceptionHandler::ContextSetter ectxguard{&ectx};
#endif // MODPLUG_TRACKER
		DWORD exception = SETryOrError(maskCrashes, [&](){ library = LoadLibrary(pluginPath.AsNative().c_str()); });
		if(exception)
		{
			CVstPluginManager::ReportPlugException(MPT_UFORMAT("Exception caught while loading {}")(pluginPath));
			return nullptr;
		}
	}
	if(library == nullptr)
	{
		DWORD error = GetLastError();
		if(error == ERROR_MOD_NOT_FOUND)
		{
			return nullptr;
		} else if(error == ERROR_DLL_INIT_FAILED)
		{
			// A likely reason for this error is that Fiber Local Storage slots are exhausted, e.g. because too many plugins ship with a statically linked runtime.
			// Before Windows 10 1903, there was a limit of 128 FLS slots per process, and the VS2017 runtime uses two FLS slots, so this could cause a worst-case limit
			// of 62 different plugins per process (assuming they all use a statically-linked runtime).
			// In Windows 10 1903, the FLS limit was finally raised, so this message is mostly relevant for older systems.
			CVstPluginManager::ReportPlugException(U_("Plugin initialization failed. This may be caused by loading too many plugins.\nTry activating the Plugin Bridge for this plugin."));
		}

#ifdef _DEBUG
		mpt::ustring buf = MPT_UFORMAT("Warning: encountered problem when loading plugin dll. Error {}: {}")
			( mpt::ufmt::hex(error)
			, mpt::ToUnicode(mpt::windows::GetErrorMessage(error))
			);
		Reporting::Error(buf, "DEBUG: Error when loading plugin dll");
#endif //_DEBUG
	}

	if(library != nullptr && library != INVALID_HANDLE_VALUE)
	{
		auto pMainProc = (Vst::MainProc)GetProcAddress(library, "VSTPluginMain");
		if(pMainProc == nullptr)
		{
			pMainProc = (Vst::MainProc)GetProcAddress(library, "main");
		}

		if(pMainProc != nullptr)
		{
#ifdef MODPLUG_TRACKER
			ExceptionHandler::Context ectx{ MPT_UFORMAT("VST Plugin: {}")(plugin.dllPath.ToUnicode()) };
			ExceptionHandler::ContextSetter ectxguard{&ectx};
#endif // MODPLUG_TRACKER
			DWORD exception = SETryOrError(maskCrashes, [&](){ effect = pMainProc(CVstPlugin::MasterCallBack); });
			if(exception)
			{
				return nullptr;
			}
		} else
		{
#ifdef VST_LOG
			MPT_LOG_GLOBAL(LogDebug, "VST", MPT_UFORMAT("Entry point not found! (handle={})")(mpt::ufmt::PTR(library)));
#endif // VST_LOG
			return nullptr;
		}
	}

	return effect;
}

static void operator|= (Vst::VstTimeInfoFlags &lhs, Vst::VstTimeInfoFlags rhs)
{
	lhs = (lhs | rhs).as_enum();
}

intptr_t VSTCALLBACK CVstPlugin::MasterCallBack(AEffect *effect, VstOpcodeToHost opcode, int32 index, intptr_t value, void *ptr, float opt)
{
#ifdef VST_LOG
	MPT_LOG_GLOBAL(LogDebug, "VST", MPT_UFORMAT("VST plugin to host: Eff: {}, Opcode = {}, Index = {}, Value = {}, PTR = {}, OPT = {}\n")(
		mpt::ufmt::PTR(effect), mpt::ufmt::val(opcode),
		mpt::ufmt::val(index), mpt::ufmt::PTR(value), mpt::ufmt::PTR(ptr), mpt::ufmt::flt(opt, 3)));
	MPT_TRACE();
#else
	MPT_UNREFERENCED_PARAMETER(opt);
#endif

	enum
	{
		HostDoNotKnow	= 0,
		HostCanDo		= 1,
		HostCanNotDo	= -1
	};

	CVstPlugin *pVstPlugin = nullptr;
	if(effect != nullptr)
	{
		pVstPlugin = static_cast<CVstPlugin *>(effect->reservedForHost1);
	}

	switch(opcode)
	{
	// Called when plugin param is changed via gui
	case audioMasterAutomate:
		// Strum Acoustic GS-1 and Strum Electric GS-1 send audioMasterAutomate during effOpen (WTF #1),
		// but when sending back effCanBeAutomated, they just crash (WTF #2).
		// As a consequence, just generally forbid this action while the plugin is not fully initialized yet.
		if(pVstPlugin != nullptr && pVstPlugin->m_isInitialized && pVstPlugin->CanAutomateParameter(index))
		{
			// This parameter can be automated. Ugo Motion constantly sends automation callback events for parameters that cannot be automated...
			pVstPlugin->AutomateParameter((PlugParamIndex)index);
		}
		return 0;

	// Called when plugin asks for VST version supported by host
	case audioMasterVersion:
		return kVstVersion;

	// Returns the unique id of a plugin that's currently loading
	// We don't support shell plugins currently, so we only support one effect ID as well.
	case audioMasterCurrentId:
		return (effect != nullptr) ? effect->uniqueID : 0;

	// Call application idle routine (this will call effEditIdle for all open editors too)
	case audioMasterIdle:
		theApp.GetPluginManager()->OnIdle();
		return 0;

	// Inquire if an input or output is beeing connected; index enumerates input or output counting from zero,
	// value is 0 for input and != 0 otherwise. note: the return value is 0 for <true> such that older versions
	// will always return true.
	case audioMasterPinConnected:
		if (value)	//input:
			return (index < 2) ? 0 : 1;		//we only support up to 2 inputs. Remember: 0 means yes.
		else		//output:
			return (index < 2) ? 0 : 1;		//2 outputs max too

	//---from here VST 2.0 extension opcodes------------------------------------------------------

	// <value> is a filter which is currently ignored - DEPRECATED in VST 2.4
	case audioMasterWantMidi:
		return 1;

	// returns const VstTimeInfo* (or 0 if not supported)
	// <value> should contain a mask indicating which fields are required
	case audioMasterGetTime:

		if(pVstPlugin)
		{
			VstTimeInfo &timeInfo = pVstPlugin->timeInfo;
			MemsetZero(timeInfo);

			timeInfo.sampleRate = pVstPlugin->m_nSampleRate;
			CSoundFile &sndFile = pVstPlugin->GetSoundFile();
			if(pVstPlugin->IsSongPlaying())
			{
				timeInfo.flags |= kVstTransportPlaying;
				if(pVstPlugin->GetSoundFile().m_SongFlags[SONG_PATTERNLOOP]) timeInfo.flags |= kVstTransportCycleActive;
				timeInfo.samplePos = sndFile.GetTotalSampleCount();
				if(pVstPlugin->m_positionChanged)
				{
					timeInfo.flags |= kVstTransportChanged;
					pVstPlugin->lastBarStartPos = -1.0;
				}
			} else
			{
				timeInfo.flags |= kVstTransportChanged; //just stopped.
				timeInfo.samplePos = 0;
				pVstPlugin->lastBarStartPos = -1.0;
			}
			if((value & kVstNanosValid))
			{
				timeInfo.flags |= kVstNanosValid;
				timeInfo.nanoSeconds = static_cast<double>(Util::mul32to64_unsigned(timeGetTime(), 1000000));
			}
			if((value & kVstPpqPosValid))
			{
				timeInfo.flags |= kVstPpqPosValid;
				if (timeInfo.flags & kVstTransportPlaying)
				{
					timeInfo.ppqPos = (timeInfo.samplePos / timeInfo.sampleRate) * (sndFile.GetCurrentBPM() / 60.0);
				} else
				{
					timeInfo.ppqPos = 0;
				}

				ROWINDEX rpm = pVstPlugin->GetSoundFile().m_PlayState.m_nCurrentRowsPerMeasure;
				if(!rpm)
					rpm = 4;
				if((pVstPlugin->GetSoundFile().m_PlayState.m_nRow % rpm) == 0)
				{
					pVstPlugin->lastBarStartPos = std::floor(timeInfo.ppqPos);
				}
				if(pVstPlugin->lastBarStartPos >= 0)
				{
					timeInfo.barStartPos = pVstPlugin->lastBarStartPos;
					timeInfo.flags |= kVstBarsValid;
				}
			}
			if((value & kVstTempoValid))
			{
				timeInfo.tempo = sndFile.GetCurrentBPM();
				if (timeInfo.tempo)
				{
					timeInfo.flags |= kVstTempoValid;
				}
			}
			if((value & kVstTimeSigValid))
			{
				timeInfo.flags |= kVstTimeSigValid;

				// Time signature. numerator = rows per beats / rows pear measure (should sound somewhat logical to you).
				// the denominator is a bit more tricky, since it cannot be set explicitely. so we just assume quarters for now.
				ROWINDEX rpb = std::max(sndFile.m_PlayState.m_nCurrentRowsPerBeat, ROWINDEX(1));
				timeInfo.timeSigNumerator = std::max(sndFile.m_PlayState.m_nCurrentRowsPerMeasure, rpb) / rpb;
				timeInfo.timeSigDenominator = 4; //std::gcd(pSndFile->m_nCurrentRowsPerMeasure, pSndFile->m_nCurrentRowsPerBeat);
			}
			return ToIntPtr(&timeInfo);
		} else
		{
			MemsetZero(g_timeInfoFallback);
			return ToIntPtr(&g_timeInfoFallback);
		}

	// Receive MIDI events from plugin
	case audioMasterProcessEvents:
		if(pVstPlugin != nullptr && ptr != nullptr)
		{
			pVstPlugin->ReceiveVSTEvents(static_cast<VstEvents *>(ptr));
			return 1;
		}
		break;

	// DEPRECATED in VST 2.4
	case audioMasterSetTime:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Set Time"));
		break;

	// returns tempo (in bpm * 10000) at sample frame location passed in <value> - DEPRECATED in VST 2.4
	case audioMasterTempoAt:
		// Screw it! Let's just return the tempo at this point in time (might be a bit wrong).
		if (pVstPlugin != nullptr)
		{
			return mpt::saturate_round<int32>(pVstPlugin->GetSoundFile().GetCurrentBPM() * 10000);
		}
		return (125 * 10000);

	// parameters - DEPRECATED in VST 2.4
	case audioMasterGetNumAutomatableParameters:
		//MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Get Num Automatable Parameters"));
		if(pVstPlugin != nullptr)
		{
			return pVstPlugin->GetNumParameters();
		}
		break;

	// Apparently, this one is broken in VST SDK anyway. - DEPRECATED in VST 2.4
	case audioMasterGetParameterQuantization:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Audio Master Get Parameter Quantization"));
		break;

	// numInputs and/or numOutputs has changed
	case audioMasterIOChanged:
		if(pVstPlugin != nullptr)
		{
			CriticalSection cs;
			return pVstPlugin->InitializeIOBuffers() ? 1 : 0;
		}
		break;

	// Plugin needs idle calls (outside its editor window) - DEPRECATED in VST 2.4
	case audioMasterNeedIdle:
		if(pVstPlugin != nullptr)
		{
			pVstPlugin->m_needIdle = true;
		}

		return 1;

	// index: width, value: height
	case audioMasterSizeWindow:
		if(pVstPlugin != nullptr)
		{
			CAbstractVstEditor *pVstEditor = pVstPlugin->GetEditor();
			if (pVstEditor && pVstEditor->IsResizable())
			{
				pVstEditor->SetSize(index, static_cast<int>(value));
			}
		}
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Size Window"));
		return 1;

	case audioMasterGetSampleRate:
		if(pVstPlugin)
		{
			return pVstPlugin->m_nSampleRate;
		} else
		{
			// HERCs Abakos queries the sample rate while the plugin is being created and then never again...
			return TrackerSettings::Instance().GetMixerSettings().gdwMixingFreq;
		}

	case audioMasterGetBlockSize:
		return MIXBUFFERSIZE;

	case audioMasterGetInputLatency:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Get Input Latency"));
		break;

	case audioMasterGetOutputLatency:
		if(pVstPlugin)
		{
			return mpt::saturate_round<intptr_t>(pVstPlugin->GetOutputLatency() * pVstPlugin->GetSoundFile().GetSampleRate());
		}
		break;

	// input pin in <value> (-1: first to come), returns cEffect* - DEPRECATED in VST 2.4
	case audioMasterGetPreviousPlug:
		if(pVstPlugin != nullptr)
		{
			std::vector<IMixPlugin *> list;
			if(pVstPlugin->GetInputPlugList(list) != 0)
			{
				// We don't assign plugins to pins...
				CVstPlugin *plugin = dynamic_cast<CVstPlugin *>(list[0]);
				if(plugin != nullptr)
				{
					return ToIntPtr(&plugin->m_Effect);
				}
			}
		}
		break;

	// output pin in <value> (-1: first to come), returns cEffect* - DEPRECATED in VST 2.4
	case audioMasterGetNextPlug:
		if(pVstPlugin != nullptr)
		{
			std::vector<IMixPlugin *> list;
			if(pVstPlugin->GetOutputPlugList(list) != 0)
			{
				// We don't assign plugins to pins...
				CVstPlugin *plugin = dynamic_cast<CVstPlugin *>(list[0]);
				if(plugin != nullptr)
				{
					return ToIntPtr(&plugin->m_Effect);
				}
			}
		}
		break;

	// realtime info
	// returns: 0: not supported, 1: replace, 2: accumulate - DEPRECATED in VST 2.4 (replace is default)
	case audioMasterWillReplaceOrAccumulate:
		return 1; //we replace.

	case audioMasterGetCurrentProcessLevel:
		if(pVstPlugin != nullptr && pVstPlugin->GetSoundFile().IsRenderingToDisc())
			return kVstProcessLevelOffline;
		else
			return kVstProcessLevelRealtime;
		break;

	// returns 0: not supported, 1: off, 2:read, 3:write, 4:read/write
	case audioMasterGetAutomationState:
		// Not entirely sure what this means. We can write automation TO the plug.
		// Is that "read" in this context?
		//MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Get Automation State"));
		return kVstAutomationReadWrite;

	case audioMasterOfflineStart:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Offlinestart"));
		break;

	case audioMasterOfflineRead:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Offlineread"));
		break;

	case audioMasterOfflineWrite:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Offlinewrite"));
		break;

	case audioMasterOfflineGetCurrentPass:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: OfflineGetcurrentpass"));
		break;

	case audioMasterOfflineGetCurrentMetaPass:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: OfflineGetCurrentMetapass"));
		break;

	// for variable i/o, sample rate in <opt> - DEPRECATED in VST 2.4
	case audioMasterSetOutputSampleRate:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Set Output Sample Rate"));
		break;

	// result in ret - DEPRECATED in VST 2.4
	case audioMasterGetOutputSpeakerArrangement:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Get Output Speaker Arrangement"));
		break;

	case audioMasterGetVendorString:
		strcpy((char *) ptr, TrackerSettings::Instance().vstHostVendorString.Get().c_str());
		return 1;

	case audioMasterGetProductString:
		strcpy((char *) ptr, TrackerSettings::Instance().vstHostProductString.Get().c_str());
		return 1;

	case audioMasterGetVendorVersion:
		return TrackerSettings::Instance().vstHostVendorVersion;

	case audioMasterVendorSpecific:
		return 0;

	// void* in <ptr>, format not defined yet - DEPRECATED in VST 2.4
	case audioMasterSetIcon:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Set Icon"));
		break;

	// string in ptr, see below
	case audioMasterCanDo:
		//Other possible Can Do strings are:
		if(!strcmp((char*)ptr, HostCanDo::sendVstEvents)
		   || !strcmp((char *)ptr, HostCanDo::sendVstMidiEvent)
		   || !strcmp((char *)ptr, HostCanDo::sendVstTimeInfo)
		   || !strcmp((char *)ptr, HostCanDo::receiveVstEvents)
		   || !strcmp((char *)ptr, HostCanDo::receiveVstMidiEvent)
		   || !strcmp((char *)ptr, HostCanDo::supplyIdle)
		   || !strcmp((char *)ptr, HostCanDo::sizeWindow)
		   || !strcmp((char *)ptr, HostCanDo::openFileSelector)
		   || !strcmp((char *)ptr, HostCanDo::closeFileSelector)
		   || !strcmp((char *)ptr, HostCanDo::acceptIOChanges)
		   || !strcmp((char *)ptr, HostCanDo::reportConnectionChanges))
		{
			return HostCanDo;
		} else
		{
			return HostCanNotDo;
		}

	case audioMasterGetLanguage:
		return kVstLangEnglish;

	// returns platform specific ptr - DEPRECATED in VST 2.4
	case audioMasterOpenWindow:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Open Window"));
		break;

	// close window, platform specific handle in <ptr> - DEPRECATED in VST 2.4
	case audioMasterCloseWindow:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Close Window"));
		break;

	// get plugin directory, FSSpec on MAC, else char*
	case audioMasterGetDirectory:
		//MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Get Directory"));
		// Need to allocate space for path only, but I guess noone relies on this anyway.
		//return ToVstPtr(pVstPlugin->GetPluginFactory().dllPath.GetPath().ToLocale());
		//return ToVstPtr(TrackerSettings::Instance().PathPlugins.GetDefaultDir());
		break;

	// something has changed, update 'multi-fx' display
	case audioMasterUpdateDisplay:
		if(pVstPlugin != nullptr)
		{
			// Note to self for testing: Electri-Q sends opcode. Korg M1 sends this when switching between Combi and Multi mode to update the preset names.
			CAbstractVstEditor *pVstEditor = pVstPlugin->GetEditor();
			if(pVstEditor && ::IsWindow(pVstEditor->m_hWnd))
			{
				pVstEditor->UpdateDisplay();
			}
		}
		return 0;

	//---from here VST 2.1 extension opcodes------------------------------------------------------

	// begin of automation session (when mouse down), parameter index in <index>
	case audioMasterBeginEdit:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Begin Edit"));
		break;

	// end of automation session (when mouse up),     parameter index in <index>
	case audioMasterEndEdit:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: End Edit"));
		break;

	// open a fileselector window with VstFileSelect* in <ptr>
	case audioMasterOpenFileSelector:

	//---from here VST 2.2 extension opcodes------------------------------------------------------

	// close a fileselector operation with VstFileSelect* in <ptr>: Must be always called after an open !
	case audioMasterCloseFileSelector:
		if(pVstPlugin != nullptr && ptr != nullptr)
		{
			return pVstPlugin->VstFileSelector(opcode == audioMasterCloseFileSelector, *static_cast<VstFileSelect *>(ptr));
		}

	// open an editor for audio (defined by XML text in ptr) - DEPRECATED in VST 2.4
	case audioMasterEditFile:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Edit File"));
		break;

	// get the native path of currently loading bank or project
	// (called from writeChunk) void* in <ptr> (char[2048], or sizeof(FSSpec)) - DEPRECATED in VST 2.4
	// Note: The shortcircuit VSTi actually uses this feature.
	case audioMasterGetChunkFile:
#ifdef MODPLUG_TRACKER
		if(pVstPlugin && pVstPlugin->GetModDoc())
		{
			mpt::ustring pathStr = TrackerSettings::Instance().pluginProjectPath;
			if(pathStr.empty())
			{
				pathStr = U_("%1");
			}
			const mpt::PathString projectPath = pVstPlugin->GetModDoc()->GetPathNameMpt().GetPath();
			const mpt::PathString projectFile = pVstPlugin->GetModDoc()->GetPathNameMpt().GetFullFileName();
			pathStr = mpt::String::Replace(pathStr, U_("%1"), U_("?1?"));
			pathStr = mpt::String::Replace(pathStr, U_("%2"), U_("?2?"));
			pathStr = mpt::String::Replace(pathStr, U_("?1?"), projectPath.ToUnicode());
			pathStr = mpt::String::Replace(pathStr, U_("?2?"), projectFile.ToUnicode());
			mpt::PathString path = mpt::PathString::FromUnicode(pathStr);
			if(path.empty())
			{
				return 0;
			}
			path.EnsureTrailingSlash();
			::SHCreateDirectoryEx(NULL, path.AsNative().c_str(), nullptr);
			path += projectFile;
			strcpy(static_cast<char*>(ptr), path.ToLocale().c_str());
			return 1;
		}
#endif
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Get Chunk File"));
		break;

	//---from here VST 2.3 extension opcodes------------------------------------------------------

	// result a VstSpeakerArrangement in ret - DEPRECATED in VST 2.4
	case audioMasterGetInputSpeakerArrangement:
		MPT_LOG_GLOBAL(LogDebug, "VST", U_("VST plugin to host: Get Input Speaker Arrangement"));
		break;

	}

	// Unknown codes:

	return 0;
}


// Helper function for file selection dialog stuff.
intptr_t CVstPlugin::VstFileSelector(bool destructor, VstFileSelect &fileSel)
{
	if(!destructor)
	{
		fileSel.returnMultiplePaths = nullptr;
		fileSel.numReturnPaths = 0;
		fileSel.reserved = 0;

		std::string returnPath;
		if(fileSel.command != kVstDirectorySelect)
		{
			// Plugin wants to load or save a file.
			std::string extensions, workingDir;
			for(int32 i = 0; i < fileSel.numFileTypes; i++)
			{
				const VstFileType &type = fileSel.fileTypes[i];
				extensions += type.name;
				extensions += "|";
#if MPT_OS_WINDOWS
				extensions += "*.";
				extensions += type.dosType;
#elif MPT_OS_MACOSX_OR_IOS
				extensions += "*";
				extensions += type.macType;
#elif MPT_OS_GENERIC_UNIX
				extensions += "*.";
				extensions += type.unixType;
#else
#error Platform-specific code missing
#endif
				extensions += "|";
			}
			extensions += "|";

			if(fileSel.initialPath != nullptr)
			{
				workingDir = fileSel.initialPath;
			} else
			{
				// Plugins are probably looking for presets...?
				//workingDir = TrackerSettings::Instance().PathPluginPresets.GetWorkingDir();
			}

			FileDialog dlg = OpenFileDialog();
			if(fileSel.command == kVstFileSave)
			{
				dlg = SaveFileDialog();
			} else if(fileSel.command == kVstMultipleFilesLoad)
			{
				dlg = OpenFileDialog().AllowMultiSelect();
			}
			dlg.ExtensionFilter(extensions)
				.WorkingDirectory(mpt::PathString::FromLocale(workingDir))
				.AddPlace(GetPluginFactory().dllPath.GetPath());
			if(!dlg.Show(GetEditor()))
				return 0;

			if(fileSel.command == kVstMultipleFilesLoad)
			{
				// Multiple paths
				const auto &files = dlg.GetFilenames();
				fileSel.numReturnPaths = mpt::saturate_cast<int32>(files.size());
				fileSel.returnMultiplePaths = new (std::nothrow) char *[fileSel.numReturnPaths];
				if(!fileSel.returnMultiplePaths)
					return 0;
				for(int32 i = 0; i < fileSel.numReturnPaths; i++)
				{
					const std::string fname_ = files[i].ToLocale();
					char *fname = new (std::nothrow) char[fname_.length() + 1];
					if(fname)
						strcpy(fname, fname_.c_str());
					fileSel.returnMultiplePaths[i] = fname;
				}
				return 1;
			} else
			{
				// Single path

				// VOPM doesn't initialize required information properly (it doesn't memset the struct to 0)...
				if(FourCC("VOPM") == GetUID())
				{
					fileSel.sizeReturnPath = _MAX_PATH;
				}

				returnPath = dlg.GetFirstFile().ToLocale();
			}
		} else
		{
			// Plugin wants a directory
			BrowseForFolder dlg(mpt::PathString::FromLocale(fileSel.initialPath != nullptr ? fileSel.initialPath : ""), mpt::ToCString(mpt::Charset::Locale, fileSel.title != nullptr ? fileSel.title : ""));
			if(!dlg.Show(GetEditor()))
				return 0;

			returnPath = dlg.GetDirectory().ToLocale();
			if(FourCC("VSTr") == GetUID() && fileSel.returnPath != nullptr && fileSel.sizeReturnPath == 0)
			{
				// Old versions of reViSiT (which still relied on the host's file selector) seem to be dodgy.
				// They report a path size of 0, but when using an own buffer, they will crash.
				// So we'll just assume that reViSiT can handle long enough (_MAX_PATH) paths here.
				fileSel.sizeReturnPath = mpt::saturate_cast<int32>(returnPath.length() + 1);
			}
		}

		// Return single path (file or directory)
		if(fileSel.returnPath == nullptr || fileSel.sizeReturnPath == 0)
		{
			// Provide some memory for the return path.
			fileSel.sizeReturnPath = mpt::saturate_cast<int32>(returnPath.length() + 1);
			fileSel.returnPath = new(std::nothrow) char[fileSel.sizeReturnPath];
			if(fileSel.returnPath == nullptr)
			{
				return 0;
			}
			fileSel.reserved = 1;
		} else
		{
			fileSel.reserved = 0;
		}
		const auto len = std::min(returnPath.size(), static_cast<size_t>(fileSel.sizeReturnPath - 1));
		strncpy(fileSel.returnPath, returnPath.data(), len);
		fileSel.returnPath[len] = '\0';
		fileSel.numReturnPaths = 1;
		fileSel.returnMultiplePaths = nullptr;
		return 1;
	} else
	{
		// Close file selector - delete allocated strings.
		if(fileSel.command == kVstMultipleFilesLoad && fileSel.returnMultiplePaths != nullptr)
		{
			for(int32 i = 0; i < fileSel.numReturnPaths; i++)
			{
				if(fileSel.returnMultiplePaths[i] != nullptr)
				{
					delete[] fileSel.returnMultiplePaths[i];
				}
			}
			delete[] fileSel.returnMultiplePaths;
			fileSel.returnMultiplePaths = nullptr;
		} else
		{
			if(fileSel.reserved == 1 && fileSel.returnPath != nullptr)
			{
				delete[] fileSel.returnPath;
				fileSel.returnPath = nullptr;
			}
		}
		return 1;
	}
}


//////////////////////////////////////////////////////////////////////////////
//
// CVstPlugin
//

CVstPlugin::CVstPlugin(bool maskCrashes, HMODULE hLibrary, VSTPluginLib &factory, SNDMIXPLUGIN &mixStruct, AEffect &effect, CSoundFile &sndFile)
	: IMidiPlugin(factory, sndFile, &mixStruct)
	, m_maskCrashes(maskCrashes)
	, m_Effect(effect)
	, timeInfo{}
	, isBridged(!memcmp(&effect.reservedForHost2, "OMPT", 4))
	, m_hLibrary(hLibrary)
	, m_nSampleRate(sndFile.GetSampleRate())
	, m_isInitialized(false)
	, m_needIdle(false)
{
	// Open plugin and initialize data structures
	Initialize();
	InsertIntoFactoryList();

	m_isInitialized = true;
}


void CVstPlugin::Initialize()
{

	m_Ectx = { MPT_UFORMAT("VST Plugin: {}")(m_Factory.dllPath.ToUnicode()) };

	// If filename matched during load but plugin ID didn't, make sure it's updated.
	m_pMixStruct->Info.dwPluginId1 = m_Factory.pluginId1 = m_Effect.magic;
	m_pMixStruct->Info.dwPluginId2 = m_Factory.pluginId2 = m_Effect.uniqueID;

	// Store a pointer so we can get the CVstPlugin object from the basic VST effect object.
	m_Effect.reservedForHost1 = this;
	m_nSampleRate = m_SndFile.GetSampleRate();

	// First try to let the plugin know the render parameters.
	Dispatch(effSetSampleRate, 0, 0, nullptr, static_cast<float>(m_nSampleRate));
	Dispatch(effSetBlockSize, 0, MIXBUFFERSIZE, nullptr, 0.0f);

	Dispatch(effOpen, 0, 0, nullptr, 0.0f);

	// VST 2.0 plugins return 2 here, VST 2.4 plugins return 2400... Great!
	m_isVst2 = Dispatch(effGetVstVersion, 0,0, nullptr, 0.0f) >= 2;
	if(m_isVst2)
	{
		// Set VST speaker in/out setup to Stereo. Required for some plugins (e.g. Voxengo SPAN 2)
		// All this might get more interesting when adding sidechaining support...
		VstSpeakerArrangement sa{};
		sa.numChannels = 2;
		sa.type = kSpeakerArrStereo;
		for(std::size_t i = 0; i < std::size(sa.speakers); i++)
		{
			// For now, only left and right speaker are used.
			switch(i)
			{
			case 0:
				sa.speakers[i].type = kSpeakerL;
				mpt::String::WriteAutoBuf(sa.speakers[i].name) = "Left";
				break;
			case 1:
				sa.speakers[i].type = kSpeakerR;
				mpt::String::WriteAutoBuf(sa.speakers[i].name) = "Right";
				break;
			default:
				sa.speakers[i].type = kSpeakerUndefined;
				break;
			}
		}

		// For some reason, this call crashes in a call to free() in AdmiralQuality NaiveLPF / SCAMP 1.2 (newer versions are fine).
		// This does not happen when running the plugin in pretty much any host, or when running in OpenMPT 1.22 and older
		// (EXCEPT when recompiling those old versions with VS2010), so it sounds like an ASLR issue to me.
		// AdmiralQuality also doesn't know what to do.
		if(GetUID() != FourCC("CSI4"))
		{
			// For now, input setup = output setup.
			Dispatch(effSetSpeakerArrangement, 0, ToIntPtr(&sa), &sa, 0.0f);
		}

		// Dummy pin properties collection.
		// We don't use them but some plugs might do inits in here.
		VstPinProperties tempPinProperties;
		Dispatch(effGetInputProperties, 0, 0, &tempPinProperties, 0);
		Dispatch(effGetOutputProperties, 0, 0, &tempPinProperties, 0);

		Dispatch(effConnectInput, 0, 1, nullptr, 0.0f);
		if (m_Effect.numInputs > 1) Dispatch(effConnectInput, 1, 1, nullptr, 0.0f);
		Dispatch(effConnectOutput, 0, 1, nullptr, 0.0f);
		if (m_Effect.numOutputs > 1) Dispatch(effConnectOutput, 1, 1, nullptr, 0.0f);
		// Disable all inputs and outputs beyond stereo left and right:
		for(int32 i = 2; i < m_Effect.numInputs; i++)
			Dispatch(effConnectInput, i, 0, nullptr, 0.0f);
		for(int32 i = 2; i < m_Effect.numOutputs; i++)
			Dispatch(effConnectOutput, i, 0, nullptr, 0.0f);
	}

	// Second try to let the plugin know the render parameters.
	Dispatch(effSetSampleRate, 0, 0, nullptr, static_cast<float>(m_nSampleRate));
	Dispatch(effSetBlockSize, 0, MIXBUFFERSIZE, nullptr, 0.0f);
	if(m_Effect.numPrograms > 0)
	{
		BeginSetProgram(0);
		EndSetProgram();
	}

	InitializeIOBuffers();

	Dispatch(effSetProcessPrecision, 0, kVstProcessPrecision32, nullptr, 0.0f);

	m_isInstrument = IsInstrument();
	RecalculateGain();
	m_pProcessFP = (m_Effect.flags & effFlagsCanReplacing) ? m_Effect.processReplacing : m_Effect.process;

	// Issue samplerate again here, cos some plugs like it before the block size, other like it right at the end.
	Dispatch(effSetSampleRate, 0, 0, nullptr, static_cast<float>(m_nSampleRate));

	// Korg Wavestation GUI won't work until plugin was resumed at least once.
	// On the other hand, some other plugins (notably Synthedit plugins like Superwave P8 2.3 or Rez 3.0) don't like this
	// and won't load their stored plugin data instantly, so only do this for the troublesome plugins...
	// Also apply this fix for Korg's M1 plugin, as this will fixes older versions of said plugin, newer versions don't require the fix.
	// EZDrummer / Superior Drummer won't load their samples until playback has started.
	if(GetUID() == FourCC("KLWV")      // Wavestation
		|| GetUID() == FourCC("KLM1")  // M1
		|| GetUID() == FourCC("dfhe")  // EZDrummer
		|| GetUID() == FourCC("dfh2")) // Superior Drummer
	{
		Resume();
		Suspend();
	}
}


bool CVstPlugin::InitializeIOBuffers()
{
	// Input pointer array size must be >= 2 for now - the input buffer assignment might write to non allocated mem. otherwise
	// In case of a bridged plugin, the AEffect struct has been updated before calling this opcode, so we don't have to worry about it being up-to-date.
	return m_mixBuffer.Initialize(std::max(m_Effect.numInputs, int32(2)), m_Effect.numOutputs);
}


CVstPlugin::~CVstPlugin()
{
	CriticalSection cs;

	CloseEditor();
	if (m_isVst2)
	{
		Dispatch(effConnectInput, 0, 0, nullptr, 0);
		if (m_Effect.numInputs > 1) Dispatch(effConnectInput, 1, 0, nullptr, 0);
		Dispatch(effConnectOutput, 0, 0, nullptr, 0);
		if (m_Effect.numOutputs > 1) Dispatch(effConnectOutput, 1, 0, nullptr, 0);
	}
	CVstPlugin::Suspend();
	m_isInitialized = false;

	Dispatch(effClose, 0, 0, nullptr, 0);
	if(TrackerSettings::Instance().BrokenPluginsWorkaroundVSTNeverUnloadAnyPlugin)
	{
		// Buggy SynthEdit 1.4 plugins: Showing a SynthEdit 1.4 plugin's editor, fully unloading the plugin,
		// then loading another (unrelated) SynthEdit 1.4 plugin and showing its editor causes a crash.
	} else
	{
		if(m_hLibrary)
		{
			FreeLibrary(m_hLibrary);
		}
	}

}


void CVstPlugin::Release()
{
	delete this;
}


void CVstPlugin::Idle()
{
	if(m_needIdle)
	{
		if(!(Dispatch(effIdle, 0, 0, nullptr, 0.0f)))
			m_needIdle = false;
	}
	if (m_pEditor && m_pEditor->m_hWnd)
	{
		Dispatch(effEditIdle, 0, 0, nullptr, 0.0f);
	}
}


int32 CVstPlugin::GetNumPrograms() const
{
	return std::max(m_Effect.numPrograms, int32(0));
}


PlugParamIndex CVstPlugin::GetNumParameters() const
{
	return m_Effect.numParams;
}


// Check whether a VST parameter can be automated
bool CVstPlugin::CanAutomateParameter(PlugParamIndex index)
{
	return (Dispatch(effCanBeAutomated, index, 0, nullptr, 0.0f) != 0);
}


int32 CVstPlugin::GetUID() const
{
	return m_Effect.uniqueID;
}


int32 CVstPlugin::GetVersion() const
{
	return m_Effect.version;
}


// Wrapper for VST dispatch call with structured exception handling.
intptr_t CVstPlugin::DispatchSEH(bool maskCrashes, AEffect *effect, VstOpcodeToPlugin opCode, int32 index, intptr_t value, void *ptr, float opt, unsigned long &exception)
{
	if(effect->dispatcher != nullptr)
	{
		intptr_t result = 0;
		DWORD e = SETryOrError(maskCrashes, [&](){ result = effect->dispatcher(effect, opCode, index, value, ptr, opt); });
		if(e)
		{
			exception = e;
		}
		return result;
	}
	return 0;
}


intptr_t CVstPlugin::Dispatch(VstOpcodeToPlugin opCode, int32 index, intptr_t value, void *ptr, float opt)
{
#ifdef VST_LOG
	{
		mpt::ustring codeStr;
		if(opCode >= 0 && static_cast<std::size_t>(opCode) < std::size(VstOpCodes))
		{
			codeStr = mpt::ToUnicode(mpt::Charset::ASCII, VstOpCodes[opCode]);
		} else
		{
			codeStr = mpt::ufmt::val(opCode);
		}
		MPT_LOG_GLOBAL(LogDebug, "VST", MPT_UFORMAT("About to Dispatch({}) (Plugin=\"{}\"), index: {}, value: {}, ptr: {}, opt: {}!\n")(codeStr, m_Factory.libraryName, index, mpt::ufmt::PTR(value), mpt::ufmt::PTR(ptr), mpt::ufmt::flt(opt, 3)));
	}
#endif
	if(!m_Effect.dispatcher)
	{
		return 0;
	}
	intptr_t result = 0;
	{
		DWORD exception = SETryOrError([&](){ result = m_Effect.dispatcher(&m_Effect, opCode, index, value, ptr, opt); });
		if(exception)
		{
			mpt::ustring codeStr;
			if(opCode < mpt::saturate_cast<int32>(std::size(VstOpCodes)))
			{
				codeStr = mpt::ToUnicode(mpt::Charset::ASCII, VstOpCodes[opCode]);
			} else
			{
				codeStr = mpt::ufmt::val(opCode);
			}
			ReportPlugException(MPT_UFORMAT("Exception {} in Dispatch({})")(mpt::ufmt::HEX0<8>(exception), codeStr));
		}
	}
	return result;
}


int32 CVstPlugin::GetCurrentProgram()
{
	if(m_Effect.numPrograms > 0)
	{
		return static_cast<int32>(Dispatch(effGetProgram, 0, 0, nullptr, 0));
	}
	return 0;
}


CString CVstPlugin::GetCurrentProgramName()
{
	std::vector<char> s(256, 0);
	// kVstMaxProgNameLen is 24... too short for some plugins, so use at least 256 bytes.
	Dispatch(effGetProgramName, 0, 0, s.data(), 0);
	return mpt::ToCString(mpt::Charset::Locale, s.data());
}


void CVstPlugin::SetCurrentProgramName(const CString &name)
{
	Dispatch(effSetProgramName, 0, 0, const_cast<char *>(mpt::ToCharset(mpt::Charset::Locale, name.Left(kVstMaxProgNameLen)).c_str()), 0.0f);
}


CString CVstPlugin::GetProgramName(int32 program)
{
	// kVstMaxProgNameLen is 24... too short for some plugins, so use at least 256 bytes.
	std::vector<char> rawname(256, 0);
	if(program < m_Effect.numPrograms)
	{
		if(Dispatch(effGetProgramNameIndexed, program, -1 /*category*/, rawname.data(), 0) != 1)
		{
			// Fallback: Try to get current program name.
			rawname.assign(256, 0);
			int32 curProg = GetCurrentProgram();
			if(program != curProg)
			{
				SetCurrentProgram(program);
			}
			Dispatch(effGetProgramName, 0, 0, rawname.data(), 0);
			if(program != curProg)
			{
				SetCurrentProgram(curProg);
			}
		}
	}
	return mpt::ToCString(mpt::Charset::Locale, rawname.data());
}


void CVstPlugin::SetCurrentProgram(int32 nIndex)
{
	if(m_Effect.numPrograms > 0)
	{
		if(nIndex < m_Effect.numPrograms)
		{
			BeginSetProgram(nIndex);
			EndSetProgram();
		}
	}
}


void CVstPlugin::BeginSetProgram(int32 program)
{
	Dispatch(effBeginSetProgram, 0, 0, nullptr, 0);
	if(program != -1)
		Dispatch(effSetProgram, 0, program, nullptr, 0);
}


void CVstPlugin::EndSetProgram()
{
	Dispatch(effEndSetProgram, 0, 0, nullptr, 0);
}


void CVstPlugin::BeginGetProgram(int32 program)
{
	if(program != -1)
		Dispatch(effSetProgram, 0, program, nullptr, 0);
	if(isBridged)
		Dispatch(effVendorSpecific, kVendorOpenMPT, kBeginGetProgram, nullptr, 0);
}


void CVstPlugin::EndGetProgram()
{
	if(isBridged)
		Dispatch(effVendorSpecific, kVendorOpenMPT, kEndGetProgram, nullptr, 0);
}


PlugParamValue CVstPlugin::GetParameter(PlugParamIndex nIndex)
{
	float fResult = 0;
	if(nIndex < m_Effect.numParams && m_Effect.getParameter != nullptr)
	{
		DWORD exception = SETryOrError([&](){ fResult = m_Effect.getParameter(&m_Effect, nIndex); });
		if(exception)
		{
			//ReportPlugException(U_("Exception in getParameter (Plugin=\"{}\")!\n"), m_Factory.szLibraryName);
		}
	}
	return fResult;
}


void CVstPlugin::SetParameter(PlugParamIndex nIndex, PlugParamValue fValue)
{
	DWORD exception = 0;
	if(nIndex < m_Effect.numParams && m_Effect.setParameter)
	{
		exception = SETryOrError([&](){ m_Effect.setParameter(&m_Effect, nIndex, fValue); });
	}
	ResetSilence();
	if(exception)
	{
		//ReportPlugException(mpt::format(U_("Exception in SetParameter({}, {})!"))(nIndex, fValue));
	}
}


// Helper function for retreiving parameter name / label / display
CString CVstPlugin::GetParamPropertyString(PlugParamIndex param, Vst::VstOpcodeToPlugin opcode)
{
	if(m_Effect.numParams > 0 && param < m_Effect.numParams)
	{
		// Increased to 256 bytes since SynthMaster 2.8 writes more than 64 bytes of 0-padding. Kind of ridiculous if you consider that kVstMaxParamStrLen = 8...
		std::vector<char> s(256, 0);
		Dispatch(opcode, param, 0, s.data(), 0);
		return mpt::ToCString(mpt::Charset::Locale, s.data());
	}
	return CString();
}


CString CVstPlugin::GetParamName(PlugParamIndex param)
{
	VstParameterProperties properties{};
	if(param < m_Effect.numParams && Dispatch(effGetParameterProperties, param, 0, &properties, 0.0f) == 1)
	{
		mpt::String::SetNullTerminator(properties.label);
		return mpt::ToCString(mpt::Charset::Locale, properties.label);
	} else
	{
		return GetParamPropertyString(param, effGetParamName);
	}
}


CString CVstPlugin::GetDefaultEffectName()
{
	if(m_isVst2)
	{
		std::vector<char> s(256, 0);
		Dispatch(effGetEffectName, 0, 0, s.data(), 0);
		return mpt::ToCString(mpt::Charset::Locale, s.data());
	}
	return CString();
}


void CVstPlugin::Resume()
{
	const uint32 sampleRate = m_SndFile.GetSampleRate();

	//reset some stuff
	m_MixState.nVolDecayL = 0;
	m_MixState.nVolDecayR = 0;
	if(m_isResumed)
	{
		Dispatch(effStopProcess, 0, 0, nullptr, 0.0f);
		Dispatch(effMainsChanged, 0, 0, nullptr, 0.0f);	// calls plugin's suspend
	}
	if (sampleRate != m_nSampleRate)
	{
		m_nSampleRate = sampleRate;
		Dispatch(effSetSampleRate, 0, 0, nullptr, static_cast<float>(m_nSampleRate));
	}
	Dispatch(effSetBlockSize, 0, MIXBUFFERSIZE, nullptr, 0.0f);
	//start off some stuff
	Dispatch(effMainsChanged, 0, 1, nullptr, 0.0f);	// calls plugin's resume
	Dispatch(effStartProcess, 0, 0, nullptr, 0.0f);
	m_isResumed = true;
}


void CVstPlugin::Suspend()
{
	if(m_isResumed)
	{
		Dispatch(effStopProcess, 0, 0, nullptr, 0.0f);
		Dispatch(effMainsChanged, 0, 0, nullptr, 0.0f); // calls plugin's suspend (theoretically, plugins should clean their buffers here, but oh well, the number of plugins which don't do this is surprisingly high.)
		m_isResumed = false;
	}
}


// Send events to plugin. Returns true if there are events left to be processed.
void CVstPlugin::ProcessVSTEvents()
{
	// Process VST events
	if(m_Effect.dispatcher != nullptr && vstEvents.Finalise() > 0)
	{
		DWORD exception = SETryOrError([&](){ m_Effect.dispatcher(&m_Effect, effProcessEvents, 0, 0, &vstEvents, 0); });
		ResetSilence();
		if(exception)
		{
			ReportPlugException(MPT_UFORMAT("Exception {} in ProcessVSTEvents(numEvents:{})!")(
				mpt::ufmt::HEX0<8>(exception),
				vstEvents.size()));
		}
	}
}


// Receive events from plugin and send them to the next plugin in the chain.
void CVstPlugin::ReceiveVSTEvents(const VstEvents *events)
{
	if(m_pMixStruct == nullptr)
	{
		return;
	}

	ResetSilence();

	// I think we should only route events to plugins that are explicitely specified as output plugins of the current plugin.
	// This should probably use GetOutputPlugList here if we ever get to support multiple output plugins.
	PLUGINDEX receiver = m_pMixStruct->GetOutputPlugin();

	if(receiver != PLUGINDEX_INVALID)
	{
		IMixPlugin *plugin = m_SndFile.m_MixPlugins[receiver].pMixPlugin;
		CVstPlugin *vstPlugin = dynamic_cast<CVstPlugin *>(plugin);
		// Add all events to the plugin's queue.
		for(const auto &ev : *events)
		{
			if(vstPlugin != nullptr)
			{
				// Directly enqueue the message and preserve as much of the event data as possible (e.g. delta frames, which are currently not used by OpenMPT but might be by plugins)
				vstPlugin->vstEvents.Enqueue(ev);
			} else if(plugin != nullptr)
			{
				if(ev->type == kVstMidiType)
				{
					plugin->MidiSend(static_cast<const VstMidiEvent *>(ev)->midiData);
				} else if(ev->type == kVstSysExType)
				{
					auto event = static_cast<const VstMidiSysexEvent *>(ev);
					plugin->MidiSysexSend(mpt::as_span(mpt::byte_cast<const std::byte *>(event->sysexDump), event->dumpBytes));
				}
			}
		}
	}

#ifdef MODPLUG_TRACKER
	if(m_recordMIDIOut)
	{
		// Spam MIDI data to all views
		for(const auto &ev : *events)
		{
			if(ev->type == kVstMidiType)
			{
				VstMidiEvent *event = static_cast<VstMidiEvent *>(ev);
				::SendNotifyMessage(CMainFrame::GetMainFrame()->GetMidiRecordWnd(), WM_MOD_MIDIMSG, event->midiData, reinterpret_cast<LPARAM>(this));
			}
		}
	}
#endif // MODPLUG_TRACKER
}


void CVstPlugin::Process(float *pOutL, float *pOutR, uint32 numFrames)
{
	ProcessVSTEvents();

	// If the plugin is found & ok, continue
	if(m_pProcessFP != nullptr && m_mixBuffer.Ok())
	{
		int32 numInputs = m_Effect.numInputs, numOutputs = m_Effect.numOutputs;
		//RecalculateGain();

		// Merge stereo input before sending to the plugin if it can only handle one input.
		if (numInputs == 1)
		{
			float *plugInputL = m_mixBuffer.GetInputBuffer(0);
			float *plugInputR = m_mixBuffer.GetInputBuffer(1);
			for (uint32 i = 0; i < numFrames; i++)
			{
				plugInputL[i] = 0.5f * (plugInputL[i] + plugInputR[i]);
			}
		}

		float **outputBuffers = m_mixBuffer.GetOutputBufferArray();
		if(!isBridged)
		{
			m_mixBuffer.ClearOutputBuffers(numFrames);
		}

		// Do the VST processing magic
		MPT_ASSERT(numFrames <= MIXBUFFERSIZE);
		{
			DWORD exception = SETryOrError([&](){ m_pProcessFP(&m_Effect, m_mixBuffer.GetInputBufferArray(), outputBuffers, numFrames); });
			if(exception)
			{
				Bypass();
				mpt::ustring processMethod = (m_Effect.flags & effFlagsCanReplacing) ? U_("processReplacing") : U_("process");
				ReportPlugException(MPT_UFORMAT("The plugin threw an exception ({}) in {}. It has automatically been set to \"Bypass\".")(mpt::ufmt::HEX0<8>(exception), processMethod));
			}
		}

		// Mix outputs of multi-output VSTs:
		if(numOutputs > 2)
		{
			MPT_ASSERT(outputBuffers != nullptr);
			// first, mix extra outputs on a stereo basis
			int32 outs = numOutputs;
			// so if nOuts is not even, let process the last output later
			if((outs % 2u) == 1) outs--;

			// mix extra stereo outputs
			for(int32 iOut = 2; iOut < outs; iOut++)
			{
				for(uint32 i = 0; i < numFrames; i++)
				{
					outputBuffers[iOut % 2u][i] += outputBuffers[iOut][i]; // assumed stereo.
				}
			}

			// if m_Effect.numOutputs is odd, mix half the signal of last output to each channel
			if(outs != numOutputs)
			{
				// trick : if we are here, numOutputs = m_Effect.numOutputs - 1 !!!
				for(uint32 i = 0; i < numFrames; i++)
				{
					float v = 0.5f * outputBuffers[outs][i];
					outputBuffers[0][i] += v;
					outputBuffers[1][i] += v;
				}
			}
		}

		if(numOutputs != 0)
		{
			MPT_ASSERT(outputBuffers != nullptr);
			ProcessMixOps(pOutL, pOutR, outputBuffers[0], outputBuffers[numOutputs > 1 ? 1 : 0], numFrames);
		}

		// If the I/O format of the bridge changed in the meanwhile, update it now.
		if(isBridged && Dispatch(effVendorSpecific, kVendorOpenMPT, kCloseOldProcessingMemory, nullptr, 0.0f) != 0)
		{
			InitializeIOBuffers();
		}
	}

	vstEvents.Clear();
	m_positionChanged = false;
}


bool CVstPlugin::MidiSend(uint32 dwMidiCode)
{
	// Note-Offs go at the start of the queue (since OpenMPT 1.17). Needed for situations like this:
	// ... ..|C-5 01
	// C-5 01|=== ..
	// TODO: Should not be used with real-time notes! Letting the key go too quickly
	// (e.g. while output device is being initalized) will cause the note to be stuck!
	bool insertAtFront = (MIDIEvents::GetTypeFromEvent(dwMidiCode) == MIDIEvents::evNoteOff);

	VstMidiEvent event{};
	event.type = kVstMidiType;
	event.byteSize = sizeof(event);
	event.midiData = dwMidiCode;

	ResetSilence();
	return vstEvents.Enqueue(&event, insertAtFront);
}


bool CVstPlugin::MidiSysexSend(mpt::const_byte_span sysex)
{
	VstMidiSysexEvent event{};
	event.type = kVstSysExType;
	event.byteSize = sizeof(event);
	event.dumpBytes = mpt::saturate_cast<int32>(sysex.size());
	event.sysexDump = sysex.data();	// We will make our own copy in VstEventQueue::Enqueue

	ResetSilence();
	return vstEvents.Enqueue(&event);
}


void CVstPlugin::HardAllNotesOff()
{
	constexpr uint32 SCRATCH_BUFFER_SIZE = 64;
	float out[2][SCRATCH_BUFFER_SIZE]; // scratch buffers

	// The JUCE framework doesn't like processing while being suspended.
	const bool wasSuspended = !IsResumed();
	if(wasSuspended)
	{
		Resume();
	}

	const bool isWavestation = GetUID() == FourCC("KLWV");
	const bool isSawer = GetUID() == FourCC("SaWR");
	for(uint8 mc = 0; mc < m_MidiCh.size(); mc++)
	{
		PlugInstrChannel &channel = m_MidiCh[mc];
		channel.ResetProgram();

		SendMidiPitchBend(mc, EncodePitchBendParam(MIDIEvents::pitchBendCentre));  // centre pitch bend

		if(!isWavestation && !isSawer)
		{
			// Korg Wavestation doesn't seem to like this CC, it can introduce ghost notes or
			// prevent new notes from being played.
			// Image-Line Sawer does not like it either and resets some parameters so that the plugin is all
			// distorted afterwards.
			MidiSend(MIDIEvents::CC(MIDIEvents::MIDICC_AllControllersOff, mc, 0));
		}
		if(!isSawer)
		{
			// Image-Line Sawer takes ages to execute this CC.
			MidiSend(MIDIEvents::CC(MIDIEvents::MIDICC_AllNotesOff, mc, 0));
		}
		MidiSend(MIDIEvents::CC(MIDIEvents::MIDICC_AllSoundOff, mc, 0));

		for(std::size_t i = 0; i < std::size(channel.noteOnMap); i++)	//all notes
		{
			for(auto &c : channel.noteOnMap[i])
			{
				while(c != 0)
				{
					MidiSend(MIDIEvents::NoteOff(mc, static_cast<uint8>(i), 0));
					c--;
				}
			}
		}
	}
	// Let plugin process events
	while(vstEvents.GetNumQueuedEvents() > 0)
	{
		Process(out[0], out[1], SCRATCH_BUFFER_SIZE);
	}

	if(wasSuspended)
	{
		Suspend();
	}
}


void CVstPlugin::SaveAllParameters()
{
	if(m_pMixStruct == nullptr)
	{
		return;
	}
	m_pMixStruct->defaultProgram = -1;

	if(ProgramsAreChunks())
	{
		void *p = nullptr;

		// Try to get whole bank
		intptr_t byteSize = Dispatch(effGetChunk, 0, 0, &p, 0);

		if (!p)
		{
			// Getting bank failed, try to get just preset
			byteSize = Dispatch(effGetChunk, 1, 0, &p, 0);
		} else
		{
			// We managed to get the bank, now we need to remember which program we're on.
			m_pMixStruct->defaultProgram = GetCurrentProgram();
		}
		if (p != nullptr)
		{
			LimitMax(byteSize, Util::MaxValueOfType(byteSize) - 4);
			try
			{
				m_pMixStruct->pluginData.resize(byteSize + 4);
				auto data = m_pMixStruct->pluginData.data();
				memcpy(data, "fEvN", 4);	// 'NvEf', return value of deprecated effIdentify call
				memcpy(data + 4, p, byteSize);
				return;
			} catch(mpt::out_of_memory e)
			{
				mpt::delete_out_of_memory(e);
			}
		}
	}
	// This plugin doesn't support chunks: save parameters
	IMixPlugin::SaveAllParameters();
}


void CVstPlugin::RestoreAllParameters(int32 program)
{
	if(m_pMixStruct != nullptr && m_pMixStruct->pluginData.size() >= 4)
	{
		auto data = m_pMixStruct->pluginData.data();
		if (!memcmp(data, "fEvN", 4))	// 'NvEf', return value of deprecated effIdentify call
		{
			if ((program>=0) && (program < m_Effect.numPrograms))
			{
				// Bank
				Dispatch(effSetChunk, 0, m_pMixStruct->pluginData.size() - 4, data + 4, 0);
				SetCurrentProgram(program);
			} else
			{
				// Program
				BeginSetProgram(-1);
				Dispatch(effSetChunk, 1, m_pMixStruct->pluginData.size() - 4, data + 4, 0);
				EndSetProgram();
			}
		} else
		{
			IMixPlugin::RestoreAllParameters(program);
		}
	}
}


CAbstractVstEditor *CVstPlugin::OpenEditor()
{
	try
	{
		if(HasEditor())
			return new COwnerVstEditor(*this);
		else
			return new CDefaultVstEditor(*this);
	} catch(mpt::out_of_memory e)
	{
		mpt::delete_out_of_memory(e);
		ReportPlugException(U_("Exception in OpenEditor()"));
		return nullptr;
	}
}


void CVstPlugin::Bypass(bool bypass)
{
	Dispatch(effSetBypass, bypass ? 1 : 0, 0, nullptr, 0.0f);
	IMixPlugin::Bypass(bypass);
}


void CVstPlugin::NotifySongPlaying(bool playing)
{
	m_isSongPlaying = playing;
}


bool CVstPlugin::IsInstrument() const
{
	return ((m_Effect.flags & effFlagsIsSynth) || (!m_Effect.numInputs));
}


bool CVstPlugin::CanRecieveMidiEvents()
{
	return Dispatch(effCanDo, 0, 0, const_cast<char *>(PluginCanDo::receiveVstMidiEvent), 0.0f) != 0;
}


void CVstPlugin::ReportPlugException(const mpt::ustring &text) const
{
	CVstPluginManager::ReportPlugException(MPT_UFORMAT("{} (Plugin: {})")(text, m_Factory.libraryName));
}


// Cache program names for plugin bridge
void CVstPlugin::CacheProgramNames(int32 firstProg, int32 lastProg)
{
	if(isBridged)
	{
		int32 offsets[2] = { firstProg, lastProg };
		Dispatch(effVendorSpecific, kVendorOpenMPT, kCacheProgramNames, offsets, 0.0f);
	}
}


// Cache parameter names for plugin bridge
void CVstPlugin::CacheParameterNames(int32 firstParam, int32 lastParam)
{
	if(isBridged)
	{
		int32 offsets[2] = { firstParam, lastParam };
		Dispatch(effVendorSpecific, kVendorOpenMPT, kCacheParameterInfo, offsets, 0.0f);
	}
}


IMixPlugin::ChunkData CVstPlugin::GetChunk(bool isBank)
{
	std::byte *chunk = nullptr;
	auto size = Dispatch(effGetChunk, isBank ? 0 : 1, 0, &chunk, 0);
	if(chunk == nullptr)
	{
		size = 0;
	}
	return ChunkData(chunk, size);
}


void CVstPlugin::SetChunk(const ChunkData &chunk, bool isBank)
{
	Dispatch(effSetChunk, isBank ? 0 : 1, chunk.size(), const_cast<std::byte *>(chunk.data()), 0);
}


OPENMPT_NAMESPACE_END

#endif // MPT_WITH_VST