winamp/Src/external_dependencies/openmpt-trunk/pluginBridge/BridgeWrapper.cpp

/*
 * BridgeWrapper.cpp
 * -----------------
 * Purpose: VST plugin bridge wrapper (host side)
 * 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 "BridgeWrapper.h"
#include "../soundlib/plugins/PluginManager.h"
#include "../mptrack/Mainfrm.h"
#include "../mptrack/Mptrack.h"
#include "../mptrack/Vstplug.h"
#include "../mptrack/ExceptionHandler.h"
#include "../common/mptFileIO.h"
#include "../common/mptStringBuffer.h"
#include "../common/misc_util.h"

using namespace Vst;


OPENMPT_NAMESPACE_BEGIN

std::vector<BridgeCommon *> BridgeCommon::m_plugins;
HWND BridgeCommon::m_communicationWindow = nullptr;
int BridgeCommon::m_instanceCount = 0;
thread_local bool BridgeCommon::m_isAudioThread = false;

std::size_t GetPluginArchPointerSize(PluginArch arch)
{
	std::size_t result = 0;
	switch(arch)
	{
	case PluginArch_x86:
		result = 4;
		break;
	case PluginArch_amd64:
		result = 8;
		break;
	case PluginArch_arm:
		result = 4;
		break;
	case PluginArch_arm64:
		result = 8;
		break;
	default:
		result = 0;
		break;
	}
	return result;
}


ComponentPluginBridge::ComponentPluginBridge(PluginArch arch, Generation generation)
	: ComponentBase(ComponentTypeBundled)
	, arch(arch)
	, generation(generation)
{
}


bool ComponentPluginBridge::DoInitialize()
{
	mpt::PathString archName;
	switch(arch)
	{
	case PluginArch_x86:
		if(mpt::OS::Windows::HostCanRun(mpt::OS::Windows::GetHostArchitecture(), mpt::OS::Windows::Architecture::x86) == mpt::OS::Windows::EmulationLevel::NA)
		{
			return false;
		}
		archName = P_("x86");
		break;
	case PluginArch_amd64:
		if(mpt::OS::Windows::HostCanRun(mpt::OS::Windows::GetHostArchitecture(), mpt::OS::Windows::Architecture::amd64) == mpt::OS::Windows::EmulationLevel::NA)
		{
			return false;
		}
		archName = P_("amd64");
		break;
	case PluginArch_arm:
		if(mpt::OS::Windows::HostCanRun(mpt::OS::Windows::GetHostArchitecture(), mpt::OS::Windows::Architecture::arm) == mpt::OS::Windows::EmulationLevel::NA)
		{
			return false;
		}
		archName = P_("arm");
		break;
	case PluginArch_arm64:
		if(mpt::OS::Windows::HostCanRun(mpt::OS::Windows::GetHostArchitecture(), mpt::OS::Windows::Architecture::arm64) == mpt::OS::Windows::EmulationLevel::NA)
		{
			return false;
		}
		archName = P_("arm64");
		break;
	default:
		break;
	}
	if(archName.empty())
	{
		return false;
	}
	exeName = mpt::PathString();
	const mpt::PathString generationSuffix = (generation == Generation::Legacy) ? P_("Legacy") : P_("");
	const mpt::PathString exeNames[] =
	{
		theApp.GetInstallPath() + P_("PluginBridge") + generationSuffix + P_("-") + archName + P_(".exe"),                          // Local
		theApp.GetInstallBinPath() + archName + P_("\\") + P_("PluginBridge") + generationSuffix + P_(".exe"),                      // Multi-arch
		theApp.GetInstallBinPath() + archName + P_("\\") + P_("PluginBridge") + generationSuffix + P_("-") + archName + P_(".exe")  // Multi-arch transitional
	};
	for(const auto &candidate : exeNames)
	{
		if(candidate.IsFile())
		{
			exeName = candidate;
			break;
		}
	}
	if(exeName.empty())
	{
		availability = AvailabilityMissing;
		return false;
	}
	std::vector<WCHAR> exePath(MAX_PATH);
	while(GetModuleFileNameW(0, exePath.data(), mpt::saturate_cast<DWORD>(exePath.size())) >= exePath.size())
	{
		exePath.resize(exePath.size() * 2);
	}
	uint64 mptVersion = BridgeWrapper::GetFileVersion(exePath.data());
	uint64 bridgeVersion = BridgeWrapper::GetFileVersion(exeName.ToWide().c_str());
	if(bridgeVersion != mptVersion)
	{
		availability = AvailabilityWrongVersion;
		return false;
	}
	availability = AvailabilityOK;
	return true;
}


PluginArch BridgeWrapper::GetNativePluginBinaryType()
{
	PluginArch result = PluginArch_unknown;
	switch(mpt::OS::Windows::GetProcessArchitecture())
	{
	case mpt::OS::Windows::Architecture::x86:
		result = PluginArch_x86;
		break;
	case mpt::OS::Windows::Architecture::amd64:
		result = PluginArch_amd64;
		break;
	case mpt::OS::Windows::Architecture::arm:
		result = PluginArch_arm;
		break;
	case mpt::OS::Windows::Architecture::arm64:
		result = PluginArch_arm64;
		break;
	default:
		result = PluginArch_unknown;
		break;
	}
	return result;
}


// Check whether we need to load a 32-bit or 64-bit wrapper.
PluginArch BridgeWrapper::GetPluginBinaryType(const mpt::PathString &pluginPath)
{
	PluginArch type = PluginArch_unknown;
	mpt::ifstream file(pluginPath, std::ios::in | std::ios::binary);
	if(file.is_open())
	{
		IMAGE_DOS_HEADER dosHeader;
		IMAGE_NT_HEADERS ntHeader;
		file.read(reinterpret_cast<char *>(&dosHeader), sizeof(dosHeader));
		if(dosHeader.e_magic == IMAGE_DOS_SIGNATURE)
		{
			file.seekg(dosHeader.e_lfanew);
			file.read(reinterpret_cast<char *>(&ntHeader), sizeof(ntHeader));

			MPT_ASSERT((ntHeader.FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);
			switch(ntHeader.FileHeader.Machine)
			{
			case IMAGE_FILE_MACHINE_I386:
				type = PluginArch_x86;
				break;
			case IMAGE_FILE_MACHINE_AMD64:
				type = PluginArch_amd64;
				break;
#if defined(MPT_WITH_WINDOWS10)
			case IMAGE_FILE_MACHINE_ARM:
				type = PluginArch_arm;
				break;
			case IMAGE_FILE_MACHINE_ARM64:
				type = PluginArch_arm64;
				break;
#endif  // MPT_WITH_WINDOWS10
			default:
				type = PluginArch_unknown;
				break;
			}
		}
	}
	return type;
}


uint64 BridgeWrapper::GetFileVersion(const WCHAR *exePath)
{
	DWORD verHandle = 0;
	DWORD verSize = GetFileVersionInfoSizeW(exePath, &verHandle);
	uint64 result = 0;
	if(verSize == 0)
	{
		return result;
	}

	char *verData = new(std::nothrow) char[verSize];
	if(verData && GetFileVersionInfoW(exePath, verHandle, verSize, verData))
	{
		UINT size = 0;
		void *lpBuffer = nullptr;
		if(VerQueryValue(verData, _T("\\"), &lpBuffer, &size) && size != 0)
		{
			auto *verInfo = static_cast<const VS_FIXEDFILEINFO *>(lpBuffer);
			if(verInfo->dwSignature == 0xfeef04bd)
			{
				result = (uint64(HIWORD(verInfo->dwFileVersionMS)) << 48)
				         | (uint64(LOWORD(verInfo->dwFileVersionMS)) << 32)
				         | (uint64(HIWORD(verInfo->dwFileVersionLS)) << 16)
				         | uint64(LOWORD(verInfo->dwFileVersionLS));
			}
		}
	}
	delete[] verData;
	return result;
}


// Create a plugin bridge object
AEffect *BridgeWrapper::Create(const VSTPluginLib &plugin, bool forceLegacy)
{
	BridgeWrapper *wrapper = new(std::nothrow) BridgeWrapper();
	BridgeWrapper *sharedInstance = nullptr;
	const Generation wantedGeneration = (plugin.modernBridge && !forceLegacy) ? Generation::Modern : Generation::Legacy;

	// Should we share instances?
	if(plugin.shareBridgeInstance)
	{
		// Well, then find some instance to share with!
		CVstPlugin *vstPlug = dynamic_cast<CVstPlugin *>(plugin.pPluginsList);
		while(vstPlug != nullptr)
		{
			if(vstPlug->isBridged)
			{
				BridgeWrapper *instance = FromIntPtr<BridgeWrapper>(vstPlug->Dispatch(effVendorSpecific, kVendorOpenMPT, kGetWrapperPointer, nullptr, 0.0f));
				if(wantedGeneration == instance->m_Generation)
				{
					sharedInstance = instance;
					break;
				}
			}
			vstPlug = dynamic_cast<CVstPlugin *>(vstPlug->GetNextInstance());
		}
	}

	try
	{
		if(wrapper != nullptr && wrapper->Init(plugin.dllPath, wantedGeneration, sharedInstance) && wrapper->m_queueMem.Good())
		{
			return &wrapper->m_sharedMem->effect;
		}
		delete wrapper;
		return nullptr;
	} catch(BridgeException &)
	{
		delete wrapper;
		throw;
	}
}


BridgeWrapper::BridgeWrapper()
{
	m_thisPluginID = static_cast<int32>(m_plugins.size());
	m_plugins.push_back(this);

	if(m_instanceCount == 1)
		CreateCommunicationWindow(WindowProc);
}


BridgeWrapper::~BridgeWrapper()
{
	if(m_instanceCount == 1)
		DestroyWindow(m_communicationWindow);
}


// Initialize and launch bridge
bool BridgeWrapper::Init(const mpt::PathString &pluginPath, Generation bridgeGeneration, BridgeWrapper *sharedInstace)
{
	static uint32 plugId = 0;
	plugId++;
	const DWORD procId = GetCurrentProcessId();

	const std::wstring mapName = MPT_WFORMAT("Local\\openmpt-{}-{}")(procId, plugId);

	// Create our shared memory object.
	if(!m_queueMem.Create(mapName.c_str(), sizeof(SharedMemLayout))
	   || !CreateSignals(mapName.c_str()))
	{
		throw BridgeException("Could not initialize plugin bridge memory.");
	}
	m_sharedMem = m_queueMem.Data<SharedMemLayout>();

	if(sharedInstace == nullptr)
	{
		// Create a new bridge instance
		const PluginArch arch = GetPluginBinaryType(pluginPath);
		bool available = false;
		ComponentPluginBridge::Availability availability = ComponentPluginBridge::AvailabilityUnknown;
		switch(arch)
		{
		case PluginArch_x86:
			if(available = (bridgeGeneration == Generation::Modern) ? IsComponentAvailable(pluginBridge_x86) : IsComponentAvailable(pluginBridgeLegacy_x86); !available)
				availability = (bridgeGeneration == Generation::Modern) ? pluginBridge_x86->GetAvailability() : pluginBridgeLegacy_x86->GetAvailability();
			break;
		case PluginArch_amd64:
			if(available = (bridgeGeneration == Generation::Modern) ? IsComponentAvailable(pluginBridge_amd64) : IsComponentAvailable(pluginBridgeLegacy_amd64); !available)
				availability = (bridgeGeneration == Generation::Modern) ? pluginBridge_amd64->GetAvailability() : pluginBridgeLegacy_amd64->GetAvailability();
			break;
#if defined(MPT_WITH_WINDOWS10)
		case PluginArch_arm:
			if(available = (bridgeGeneration == Generation::Modern) ? IsComponentAvailable(pluginBridge_arm) : IsComponentAvailable(pluginBridgeLegacy_arm); !available)
				availability = (bridgeGeneration == Generation::Modern) ? pluginBridge_arm->GetAvailability() : pluginBridgeLegacy_arm->GetAvailability();
			break;
		case PluginArch_arm64:
			if(available = (bridgeGeneration == Generation::Modern) ? IsComponentAvailable(pluginBridge_arm64) : IsComponentAvailable(pluginBridgeLegacy_arm64); !available)
				availability = (bridgeGeneration == Generation::Modern) ? pluginBridge_arm64->GetAvailability() : pluginBridgeLegacy_arm64->GetAvailability();
			break;
#endif  // MPT_WITH_WINDOWS10
		default:
			break;
		}
		if(arch == PluginArch_unknown)
		{
			return false;
		}
		if(!available)
		{
			switch(availability)
			{
			case ComponentPluginBridge::AvailabilityMissing:
				// Silently fail if bridge is missing.
				throw BridgeNotFoundException();
				break;
			case ComponentPluginBridge::AvailabilityWrongVersion:
				throw BridgeException("The plugin bridge version does not match your OpenMPT version.");
				break;
			default:
				throw BridgeNotFoundException();
				break;
			}
		}
		const ComponentPluginBridge *const pluginBridge =
				(arch == PluginArch_x86 && bridgeGeneration == Generation::Modern) ? static_cast<const ComponentPluginBridge *>(pluginBridge_x86.get()) :
				(arch == PluginArch_x86 && bridgeGeneration == Generation::Legacy) ? static_cast<const ComponentPluginBridge *>(pluginBridgeLegacy_x86.get()) :
				(arch == PluginArch_amd64 && bridgeGeneration == Generation::Modern) ? static_cast<const ComponentPluginBridge *>(pluginBridge_amd64.get()) :
				(arch == PluginArch_amd64 && bridgeGeneration == Generation::Legacy) ? static_cast<const ComponentPluginBridge *>(pluginBridgeLegacy_amd64.get()) :
#if defined(MPT_WITH_WINDOWS10)
				(arch == PluginArch_arm && bridgeGeneration == Generation::Modern) ? static_cast<const ComponentPluginBridge *>(pluginBridge_arm.get()) :
				(arch == PluginArch_arm && bridgeGeneration == Generation::Legacy) ? static_cast<const ComponentPluginBridge *>(pluginBridgeLegacy_arm.get()) :
				(arch == PluginArch_arm64 && bridgeGeneration == Generation::Modern) ? static_cast<const ComponentPluginBridge *>(pluginBridge_arm64.get()) :
				(arch == PluginArch_arm64 && bridgeGeneration == Generation::Legacy) ? static_cast<const ComponentPluginBridge *>(pluginBridgeLegacy_arm64.get()) :
#endif  // MPT_WITH_WINDOWS10
		    nullptr;
		if(!pluginBridge)
		{
			return false;
		}
		m_Generation = bridgeGeneration;
		const mpt::PathString exeName = pluginBridge->GetFileName();

		m_otherPtrSize = static_cast<int32>(GetPluginArchPointerSize(arch));

		std::wstring cmdLine = MPT_WFORMAT("{} {}")(mapName, procId);

		STARTUPINFOW info;
		MemsetZero(info);
		info.cb = sizeof(info);
		PROCESS_INFORMATION processInfo;
		MemsetZero(processInfo);

		if(!CreateProcessW(exeName.ToWide().c_str(), cmdLine.data(), NULL, NULL, FALSE, 0, NULL, NULL, &info, &processInfo))
		{
			throw BridgeException("Failed to launch plugin bridge.");
		}
		CloseHandle(processInfo.hThread);
		m_otherProcess = processInfo.hProcess;
	} else
	{
		// Re-use existing bridge instance
		m_otherPtrSize = sharedInstace->m_otherPtrSize;
		m_otherProcess.DuplicateFrom(sharedInstace->m_otherProcess);

		BridgeMessage msg;
		msg.NewInstance(mapName.c_str());
		if(!sharedInstace->SendToBridge(msg))
		{
			// Something went wrong, try a new instance
			return Init(pluginPath, bridgeGeneration, nullptr);
		}
	}

	// Initialize bridge
	m_sharedMem->effect.object = this;
	m_sharedMem->effect.dispatcher = DispatchToPlugin;
	m_sharedMem->effect.setParameter = SetParameter;
	m_sharedMem->effect.getParameter = GetParameter;
	m_sharedMem->effect.process = Process;
	std::memcpy(&(m_sharedMem->effect.reservedForHost2), "OMPT", 4);

	m_sigAutomation.Create(true);

	m_sharedMem->hostCommWindow = m_communicationWindow;

	const HANDLE objects[] = {m_sigBridgeReady, m_otherProcess};
	if(WaitForMultipleObjects(mpt::saturate_cast<DWORD>(std::size(objects)), objects, FALSE, 10000) != WAIT_OBJECT_0)
	{
		throw BridgeException("Could not connect to plugin bridge, it probably crashed.");
	}
	m_otherPluginID = m_sharedMem->bridgePluginID;

	BridgeMessage initMsg;
	initMsg.Init(pluginPath.ToWide().c_str(), MIXBUFFERSIZE, m_thisPluginID, ExceptionHandler::fullMemDump);

	if(!SendToBridge(initMsg))
	{
		throw BridgeException("Could not initialize plugin bridge, it probably crashed.");
	} else if(initMsg.init.result != 1)
	{
		throw BridgeException(mpt::ToCharset(mpt::Charset::UTF8, initMsg.init.str).c_str());
	}

	if(m_sharedMem->effect.flags & effFlagsCanReplacing)
		m_sharedMem->effect.processReplacing = ProcessReplacing;
	if(m_sharedMem->effect.flags & effFlagsCanDoubleReplacing)
		m_sharedMem->effect.processDoubleReplacing = ProcessDoubleReplacing;
	return true;
}


// Send an arbitrary message to the bridge.
// Returns true if the message was processed by the bridge.
bool BridgeWrapper::SendToBridge(BridgeMessage &sendMsg)
{
	const bool inAudioThread = m_isAudioThread || CMainFrame::GetMainFrame()->InAudioThread();
	auto &messages = m_sharedMem->ipcMessages;
	const auto msgID = CopyToSharedMemory(sendMsg, messages);
	if(msgID < 0)
		return false;
	BridgeMessage &sharedMsg = messages[msgID];

	if(!inAudioThread)
	{
		if(SendMessage(m_sharedMem->bridgeCommWindow, WM_BRIDGE_MESSAGE_TO_BRIDGE, m_otherPluginID, msgID) == WM_BRIDGE_SUCCESS)
		{
			sharedMsg.CopyTo(sendMsg);
			return true;
		}
		return false;
	}

	// Audio thread: Use signals instead of window messages
	m_sharedMem->audioThreadToBridgeMsgID = msgID;
	m_sigToBridgeAudio.Send();

	// Wait until we get the result from the bridge
	DWORD result;
	const HANDLE objects[] = {m_sigToBridgeAudio.confirm, m_sigToHostAudio.send, m_otherProcess};
	do
	{
		result = WaitForMultipleObjects(mpt::saturate_cast<DWORD>(std::size(objects)), objects, FALSE, INFINITE);
		if(result == WAIT_OBJECT_0)
		{
			// Message got answered
			sharedMsg.CopyTo(sendMsg);
			break;
		} else if(result == WAIT_OBJECT_0 + 1)
		{
			ParseNextMessage(m_sharedMem->audioThreadToHostMsgID);
			m_sigToHostAudio.Confirm();
		}
	} while(result != WAIT_OBJECT_0 + 2 && result != WAIT_FAILED);

	return (result == WAIT_OBJECT_0);
}


// Receive a message from the host and translate it.
void BridgeWrapper::ParseNextMessage(int msgID)
{
	auto &msg = m_sharedMem->ipcMessages[msgID];
	switch(msg.header.type)
	{
	case MsgHeader::dispatch:
		DispatchToHost(msg.dispatch);
		break;

	case MsgHeader::errorMsg:
		// TODO Showing a message box here will deadlock as the main thread can be in a waiting state
		//throw BridgeErrorException(msg.error.str);
		break;
	}
}


void BridgeWrapper::DispatchToHost(DispatchMsg &msg)
{
	// Various dispatch data - depending on the opcode, one of those might be used.
	std::vector<char> extraData;

	MappedMemory auxMem;

	// Content of ptr is usually stored right after the message header, ptr field indicates size.
	void *ptr = (msg.ptr != 0) ? (&msg + 1) : nullptr;
	if(msg.size > sizeof(BridgeMessage))
	{
		if(!auxMem.Open(static_cast<const wchar_t *>(ptr)))
		{
			return;
		}
		ptr = auxMem.Data();
	}
	void *origPtr = ptr;

	switch(msg.opcode)
	{
	case audioMasterProcessEvents:
		// VstEvents* in [ptr]
		TranslateBridgeToVstEvents(extraData, ptr);
		ptr = extraData.data();
		break;

	case audioMasterVendorSpecific:
		if(msg.index != kVendorOpenMPT || msg.value != kUpdateProcessingBuffer)
		{
			break;
		}
		[[fallthrough]];
	case audioMasterIOChanged:
	{
		// If the song is playing, the rendering thread might be active at the moment,
		// so we should keep the current processing memory alive until it is done for sure.
		const CVstPlugin *plug = static_cast<CVstPlugin *>(m_sharedMem->effect.reservedForHost1);
		const bool isPlaying = plug != nullptr && plug->IsResumed();
		if(isPlaying)
		{
			m_oldProcessMem.CopyFrom(m_processMem);
		}
		// Set up new processing file
		m_processMem.Open(static_cast<wchar_t *>(ptr));
		if(isPlaying)
		{
			msg.result = 1;
			return;
		}
	}
	break;

	case audioMasterUpdateDisplay:
		m_cachedProgNames.clear();
		m_cachedParamInfo.clear();
		break;

	case audioMasterOpenFileSelector:
		TranslateBridgeToVstFileSelect(extraData, ptr, static_cast<size_t>(msg.ptr));
		ptr = extraData.data();
		break;
	}

	intptr_t result = CVstPlugin::MasterCallBack(&m_sharedMem->effect, static_cast<VstOpcodeToHost>(msg.opcode), msg.index, static_cast<intptr_t>(msg.value), ptr, msg.opt);
	msg.result = static_cast<int32>(result);

	// Post-fix some opcodes
	switch(msg.opcode)
	{
	case audioMasterGetTime:
		// VstTimeInfo* in [return value]
		if(msg.result != 0)
		{
			m_sharedMem->timeInfo = *FromIntPtr<VstTimeInfo>(result);
		}
		break;

	case audioMasterGetDirectory:
		// char* in [return value]
		if(msg.result != 0)
		{
			char *target = static_cast<char *>(ptr);
			strncpy(target, FromIntPtr<const char>(result), static_cast<size_t>(msg.ptr - 1));
			target[msg.ptr - 1] = 0;
		}
		break;

	case audioMasterOpenFileSelector:
		if(msg.result != 0)
		{
			std::vector<char> fileSelect;
			TranslateVstFileSelectToBridge(fileSelect, *static_cast<const VstFileSelect *>(ptr), m_otherPtrSize);
			std::memcpy(origPtr, fileSelect.data(), std::min(fileSelect.size(), static_cast<size_t>(msg.ptr)));
			// Directly free memory on host side, we don't need it anymore
			CVstPlugin::MasterCallBack(&m_sharedMem->effect, audioMasterCloseFileSelector, msg.index, static_cast<intptr_t>(msg.value), ptr, msg.opt);
		}
		break;
	}
}


intptr_t VSTCALLBACK BridgeWrapper::DispatchToPlugin(AEffect *effect, VstOpcodeToPlugin opcode, int32 index, intptr_t value, void *ptr, float opt)
{
	BridgeWrapper *that = static_cast<BridgeWrapper *>(effect->object);
	if(that != nullptr)
	{
		return that->DispatchToPlugin(opcode, index, value, ptr, opt);
	}
	return 0;
}


intptr_t BridgeWrapper::DispatchToPlugin(VstOpcodeToPlugin opcode, int32 index, intptr_t value, void *ptr, float opt)
{
	std::vector<char> dispatchData(sizeof(DispatchMsg), 0);
	int64 ptrOut = 0;
	bool copyPtrBack = false, ptrIsSize = true;
	char *ptrC = static_cast<char *>(ptr);

	switch(opcode)
	{
	case effGetParamLabel:
	case effGetParamDisplay:
	case effGetParamName:
		if(index >= m_cachedParamInfoStart && index < m_cachedParamInfoStart + mpt::saturate_cast<int32>(m_cachedParamInfo.size()))
		{
			if(opcode == effGetParamLabel)
				strcpy(ptrC, m_cachedParamInfo[index - m_cachedParamInfoStart].label);
			else if(opcode == effGetParamDisplay)
				strcpy(ptrC, m_cachedParamInfo[index - m_cachedParamInfoStart].display);
			else if(opcode == effGetParamName)
				strcpy(ptrC, m_cachedParamInfo[index - m_cachedParamInfoStart].name);
			return 1;
		}
		[[fallthrough]];
	case effGetProgramName:
	case effString2Parameter:
	case effGetProgramNameIndexed:
	case effGetEffectName:
	case effGetErrorText:
	case effGetVendorString:
	case effGetProductString:
	case effShellGetNextPlugin:
		// Name in [ptr]
		if(opcode == effGetProgramNameIndexed && !m_cachedProgNames.empty())
		{
			// First check if we have cached this program name
			if(index >= m_cachedProgNameStart && index < m_cachedProgNameStart + mpt::saturate_cast<int32>(m_cachedProgNames.size() / kCachedProgramNameLength))
			{
				strcpy(ptrC, &m_cachedProgNames[(index - m_cachedProgNameStart) * kCachedProgramNameLength]);
				return 1;
			}
		}
		ptrOut = 256;
		copyPtrBack = true;
		break;

	case effSetProgramName:
		m_cachedProgNames.clear();
		[[fallthrough]];
	case effCanDo:
		// char* in [ptr]
		ptrOut = strlen(ptrC) + 1;
		dispatchData.insert(dispatchData.end(), ptrC, ptrC + ptrOut);
		break;

	case effIdle:
		// The plugin bridge will generate these messages by itself
		return 0;

	case effEditGetRect:
		// ERect** in [ptr]
		ptrOut = sizeof(ERect);
		copyPtrBack = true;
		break;

	case effEditOpen:
		// HWND in [ptr] - Note: Window handles are interoperable between 32-bit and 64-bit applications in Windows (http://msdn.microsoft.com/en-us/library/arch/desktop/aa384203%28v=vs.85%29.aspx)
		ptrOut = reinterpret_cast<int64>(ptr);
		ptrIsSize = false;
		m_cachedProgNames.clear();
		m_cachedParamInfo.clear();
		break;

	case effEditIdle:
		// The plugin bridge will generate these messages by itself
		return 0;

	case effGetChunk:
		// void** in [ptr] for chunk data address
		{
			static uint32 chunkId = 0;
			const std::wstring mapName = L"Local\\openmpt-" + mpt::wfmt::val(GetCurrentProcessId()) + L"-chunkdata-" + mpt::wfmt::val(chunkId++);
			ptrOut = (mapName.length() + 1) * sizeof(wchar_t);
			PushToVector(dispatchData, *mapName.c_str(), static_cast<size_t>(ptrOut));
		}
		break;

	case effSetChunk:
		// void* in [ptr] for chunk data
		ptrOut = value;
		dispatchData.insert(dispatchData.end(), ptrC, ptrC + value);
		m_cachedProgNames.clear();
		m_cachedParamInfo.clear();
		break;

	case effProcessEvents:
		// VstEvents* in [ptr]
		// We process in a separate memory segment to save a bridge communication message.
		{
			std::vector<char> events;
			TranslateVstEventsToBridge(events, *static_cast<VstEvents *>(ptr), m_otherPtrSize);
			if(m_eventMem.Size() < events.size())
			{
				// Resize memory
				static uint32 chunkId = 0;
				const std::wstring mapName = L"Local\\openmpt-" + mpt::wfmt::val(GetCurrentProcessId()) + L"-events-" + mpt::wfmt::val(chunkId++);
				ptrOut = (mapName.length() + 1) * sizeof(wchar_t);
				PushToVector(dispatchData, *mapName.c_str(), static_cast<size_t>(ptrOut));
				m_eventMem.Create(mapName.c_str(), static_cast<uint32>(events.size() + 1024));

				opcode = effVendorSpecific;
				index = kVendorOpenMPT;
				value = kUpdateEventMemName;
			}
			std::memcpy(m_eventMem.Data(), events.data(), events.size());
		}
		if(opcode != effVendorSpecific)
		{
			return 1;
		}
		break;

	case effGetInputProperties:
	case effGetOutputProperties:
		// VstPinProperties* in [ptr]
		ptrOut = sizeof(VstPinProperties);
		copyPtrBack = true;
		break;

	case effOfflineNotify:
		// VstAudioFile* in [ptr]
		ptrOut = sizeof(VstAudioFile) * value;
		// TODO
		return 0;
		break;

	case effOfflinePrepare:
	case effOfflineRun:
		// VstOfflineTask* in [ptr]
		ptrOut = sizeof(VstOfflineTask) * value;
		// TODO
		return 0;
		break;

	case effProcessVarIo:
		// VstVariableIo* in [ptr]
		ptrOut = sizeof(VstVariableIo);
		// TODO
		return 0;
		break;

	case effSetSpeakerArrangement:
		// VstSpeakerArrangement* in [value] and [ptr]
		ptrOut = sizeof(VstSpeakerArrangement) * 2;
		PushToVector(dispatchData, *static_cast<VstSpeakerArrangement *>(ptr));
		PushToVector(dispatchData, *FromIntPtr<VstSpeakerArrangement>(value));
		break;

	case effVendorSpecific:
		if(index == kVendorOpenMPT)
		{
			switch(value)
			{
			case kGetWrapperPointer:
				return ToIntPtr<BridgeWrapper>(this);

			case kCloseOldProcessingMemory:
			{
				intptr_t result = m_oldProcessMem.Good();
				m_oldProcessMem.Close();
				return result;
			}

			case kCacheProgramNames:
			{
				int32 *prog = static_cast<int32 *>(ptr);
				m_cachedProgNameStart = prog[0];
				ptrOut = std::max(static_cast<int64>(sizeof(int32) * 2), static_cast<int64>((prog[1] - prog[0]) * kCachedProgramNameLength));
				dispatchData.insert(dispatchData.end(), ptrC, ptrC + 2 * sizeof(int32));
			}
			break;

			case kCacheParameterInfo:
			{
				int32 *param = static_cast<int32 *>(ptr);
				m_cachedParamInfoStart = param[0];
				ptrOut = std::max(static_cast<int64>(sizeof(int32) * 2), static_cast<int64>((param[1] - param[0]) * sizeof(ParameterInfo)));
				dispatchData.insert(dispatchData.end(), ptrC, ptrC + 2 * sizeof(int32));
			}
			break;

			case kBeginGetProgram:
				ptrOut = m_sharedMem->effect.numParams * sizeof(float);
				break;

			case kEndGetProgram:
				m_cachedParamValues.clear();
				return 1;
			}
		}
		break;

	case effGetTailSize:
		return m_sharedMem->tailSize;

	case effGetParameterProperties:
		// VstParameterProperties* in [ptr]
		if(index >= m_cachedParamInfoStart && index < m_cachedParamInfoStart + mpt::saturate_cast<int32>(m_cachedParamInfo.size()))
		{
			*static_cast<VstParameterProperties *>(ptr) = m_cachedParamInfo[index - m_cachedParamInfoStart].props;
			return 1;
		}
		ptrOut = sizeof(VstParameterProperties);
		copyPtrBack = true;
		break;

	case effGetMidiProgramName:
	case effGetCurrentMidiProgram:
		// MidiProgramName* in [ptr]
		ptrOut = sizeof(MidiProgramName);
		copyPtrBack = true;
		break;

	case effGetMidiProgramCategory:
		// MidiProgramCategory* in [ptr]
		ptrOut = sizeof(MidiProgramCategory);
		copyPtrBack = true;
		break;

	case effGetMidiKeyName:
		// MidiKeyName* in [ptr]
		ptrOut = sizeof(MidiKeyName);
		copyPtrBack = true;
		break;

	case effBeginSetProgram:
		m_isSettingProgram = true;
		break;

	case effEndSetProgram:
		m_isSettingProgram = false;
		if(m_sharedMem->automationQueue.pendingEvents)
		{
			SendAutomationQueue();
		}
		m_cachedProgNames.clear();
		m_cachedParamInfo.clear();
		break;

	case effGetSpeakerArrangement:
		// VstSpeakerArrangement* in [value] and [ptr]
		ptrOut = sizeof(VstSpeakerArrangement) * 2;
		copyPtrBack = true;
		break;

	case effBeginLoadBank:
	case effBeginLoadProgram:
		// VstPatchChunkInfo* in [ptr]
		ptrOut = sizeof(VstPatchChunkInfo);
		m_cachedProgNames.clear();
		m_cachedParamInfo.clear();
		break;

	default:
		MPT_ASSERT(ptr == nullptr);
	}

	if(ptrOut != 0 && ptrIsSize)
	{
		// In case we only reserve space and don't copy stuff over...
		dispatchData.resize(sizeof(DispatchMsg) + static_cast<size_t>(ptrOut), 0);
	}

	uint32 extraSize = static_cast<uint32>(dispatchData.size() - sizeof(DispatchMsg));

	// Create message header
	BridgeMessage &msg = *reinterpret_cast<BridgeMessage *>(dispatchData.data());
	msg.Dispatch(opcode, index, value, ptrOut, opt, extraSize);

	const bool useAuxMem = dispatchData.size() > sizeof(BridgeMessage);
	AuxMem *auxMem = nullptr;
	if(useAuxMem)
	{
		// Extra data doesn't fit in message - use secondary memory
		if(dispatchData.size() > std::numeric_limits<uint32>::max())
			return 0;
		auxMem = GetAuxMemory(mpt::saturate_cast<uint32>(dispatchData.size()));
		if(auxMem == nullptr)
			return 0;

		// First, move message data to shared memory...
		std::memcpy(auxMem->memory.Data(), &dispatchData[sizeof(DispatchMsg)], extraSize);
		// ...Now put the shared memory name in the message instead.
		std::memcpy(&dispatchData[sizeof(DispatchMsg)], auxMem->name, sizeof(auxMem->name));
	}

	try
	{
		if(!SendToBridge(msg) && opcode != effClose)
		{
			return 0;
		}
	} catch(...)
	{
		// Don't do anything for now.
#if 0
		if(opcode != effClose)
		{
			throw;
		}
#endif
	}

	const DispatchMsg &resultMsg = msg.dispatch;

	// cppcheck false-positive
	// cppcheck-suppress nullPointerRedundantCheck
	const void *extraData = useAuxMem ? auxMem->memory.Data<const char>() : reinterpret_cast<const char *>(&resultMsg + 1);
	// Post-fix some opcodes
	switch(opcode)
	{
	case effClose:
		m_sharedMem->effect.object = nullptr;
		delete this;
		return 0;

	case effGetProgramName:
	case effGetParamLabel:
	case effGetParamDisplay:
	case effGetParamName:
	case effString2Parameter:
	case effGetProgramNameIndexed:
	case effGetEffectName:
	case effGetErrorText:
	case effGetVendorString:
	case effGetProductString:
	case effShellGetNextPlugin:
		// Name in [ptr]
		strcpy(ptrC, static_cast<const char *>(extraData));
		break;

	case effEditGetRect:
		// ERect** in [ptr]
		m_editRect = *static_cast<const ERect *>(extraData);
		*static_cast<const ERect **>(ptr) = &m_editRect;
		break;

	case effGetChunk:
		// void** in [ptr] for chunk data address
		if(const wchar_t *str = static_cast<const wchar_t *>(extraData); m_getChunkMem.Open(str))
			*static_cast<void **>(ptr) = m_getChunkMem.Data();
		else
			return 0;
		break;

	case effVendorSpecific:
		if(index == kVendorOpenMPT && resultMsg.result == 1)
		{
			switch(value)
			{
			case kCacheProgramNames:
				m_cachedProgNames.assign(static_cast<const char *>(extraData), static_cast<const char *>(extraData) + ptrOut);
				break;
			case kCacheParameterInfo:
			{
				const ParameterInfo *params = static_cast<const ParameterInfo *>(extraData);
				m_cachedParamInfo.assign(params, params + ptrOut / sizeof(ParameterInfo));
				break;
			}
			case kBeginGetProgram:
				m_cachedParamValues.assign(static_cast<const float *>(extraData), static_cast<const float *>(extraData) + ptrOut / sizeof(float));
				break;
			}
		}
		break;

	case effGetSpeakerArrangement:
		// VstSpeakerArrangement* in [value] and [ptr]
		m_speakers[0] = *static_cast<const VstSpeakerArrangement *>(extraData);
		m_speakers[1] = *(static_cast<const VstSpeakerArrangement *>(extraData) + 1);
		*static_cast<VstSpeakerArrangement *>(ptr) = m_speakers[0];
		*FromIntPtr<VstSpeakerArrangement>(value) = m_speakers[1];
		break;

	default:
		// TODO: Translate VstVariableIo, offline tasks
		if(copyPtrBack)
		{
			std::memcpy(ptr, extraData, static_cast<size_t>(ptrOut));
		}
	}

	if(auxMem != nullptr)
	{
		auxMem->used = false;
	}

	return static_cast<intptr_t>(resultMsg.result);
}


// Allocate auxiliary shared memory for too long bridge messages
BridgeWrapper::AuxMem *BridgeWrapper::GetAuxMemory(uint32 size)
{
	std::size_t index = std::size(m_auxMems);
	for(int pass = 0; pass < 2; pass++)
	{
		for(std::size_t i = 0; i < std::size(m_auxMems); i++)
		{
			if(m_auxMems[i].size >= size || pass == 1)
			{
				// Good candidate - is it taken yet?
				bool expected = false;
				if(m_auxMems[i].used.compare_exchange_strong(expected, true))
				{
					index = i;
					break;
				}
			}
		}
		if(index != std::size(m_auxMems))
			break;
	}
	if(index == std::size(m_auxMems))
		return nullptr;

	AuxMem &auxMem = m_auxMems[index];
	if(auxMem.size >= size && auxMem.memory.Good())
	{
		// Re-use as-is
		return &auxMem;
	}
	// Create new memory with appropriate size
	static_assert(sizeof(DispatchMsg) + sizeof(auxMem.name) <= sizeof(BridgeMessage), "Check message sizes, this will crash!");
	static unsigned int auxMemCount = 0;
	mpt::String::WriteAutoBuf(auxMem.name) = MPT_WFORMAT("Local\\openmpt-{}-auxmem-{}")(GetCurrentProcessId(), auxMemCount++);
	if(auxMem.memory.Create(auxMem.name, size))
	{
		auxMem.size = size;
		return &auxMem;
	} else
	{
		auxMem.used = false;
		return nullptr;
	}
}


// Send any pending automation events
void BridgeWrapper::SendAutomationQueue()
{
	m_sigAutomation.Reset();
	BridgeMessage msg;
	msg.Automate();
	if(!SendToBridge(msg))
	{
		// Failed (plugin probably crashed) - auto-fix event count
		m_sharedMem->automationQueue.pendingEvents = 0;
	}
	m_sigAutomation.Trigger();
}

void VSTCALLBACK BridgeWrapper::SetParameter(AEffect *effect, int32 index, float parameter)
{
	BridgeWrapper *that = static_cast<BridgeWrapper *>(effect->object);
	if(that)
	{
		try
		{
			that->SetParameter(index, parameter);
		} catch(...)
		{
			// Be quiet about exceptions here
		}
	}
}


void BridgeWrapper::SetParameter(int32 index, float parameter)
{
	const CVstPlugin *plug = static_cast<CVstPlugin *>(m_sharedMem->effect.reservedForHost1);
	AutomationQueue &autoQueue = m_sharedMem->automationQueue;
	if(m_isSettingProgram || (plug && plug->IsResumed()))
	{
		// Queue up messages while rendering to reduce latency introduced by every single bridge call
		uint32 i;
		while((i = autoQueue.pendingEvents.fetch_add(1)) >= std::size(autoQueue.params))
		{
			// Queue full!
			if(i == std::size(autoQueue.params))
			{
				// We're the first to notice that it's full
				SendAutomationQueue();
			} else
			{
				// Wait until queue is emptied by someone else (this branch is very unlikely to happen)
				WaitForSingleObject(m_sigAutomation, INFINITE);
			}
		}

		autoQueue.params[i].index = index;
		autoQueue.params[i].value = parameter;
		return;
	} else if(autoQueue.pendingEvents)
	{
		// Actually, this should never happen as pending events are cleared before processing and at the end of a set program event.
		SendAutomationQueue();
	}

	BridgeMessage msg;
	msg.SetParameter(index, parameter);
	SendToBridge(msg);
}


float VSTCALLBACK BridgeWrapper::GetParameter(AEffect *effect, int32 index)
{
	BridgeWrapper *that = static_cast<BridgeWrapper *>(effect->object);
	if(that)
	{
		if(static_cast<size_t>(index) < that->m_cachedParamValues.size())
			return that->m_cachedParamValues[index];

		try
		{
			return that->GetParameter(index);
		} catch(...)
		{
			// Be quiet about exceptions here
		}
	}
	return 0.0f;
}


float BridgeWrapper::GetParameter(int32 index)
{
	BridgeMessage msg;
	msg.GetParameter(index);
	if(SendToBridge(msg))
	{
		return msg.parameter.value;
	}
	return 0.0f;
}


void VSTCALLBACK BridgeWrapper::Process(AEffect *effect, float **inputs, float **outputs, int32 sampleFrames)
{
	BridgeWrapper *that = static_cast<BridgeWrapper *>(effect->object);
	if(sampleFrames != 0 && that != nullptr)
	{
		that->BuildProcessBuffer(ProcessMsg::process, effect->numInputs, effect->numOutputs, inputs, outputs, sampleFrames);
	}
}


void VSTCALLBACK BridgeWrapper::ProcessReplacing(AEffect *effect, float **inputs, float **outputs, int32 sampleFrames)
{
	BridgeWrapper *that = static_cast<BridgeWrapper *>(effect->object);
	if(sampleFrames != 0 && that != nullptr)
	{
		that->BuildProcessBuffer(ProcessMsg::processReplacing, effect->numInputs, effect->numOutputs, inputs, outputs, sampleFrames);
	}
}


void VSTCALLBACK BridgeWrapper::ProcessDoubleReplacing(AEffect *effect, double **inputs, double **outputs, int32 sampleFrames)
{
	BridgeWrapper *that = static_cast<BridgeWrapper *>(effect->object);
	if(sampleFrames != 0 && that != nullptr)
	{
		that->BuildProcessBuffer(ProcessMsg::processDoubleReplacing, effect->numInputs, effect->numOutputs, inputs, outputs, sampleFrames);
	}
}


template <typename buf_t>
void BridgeWrapper::BuildProcessBuffer(ProcessMsg::ProcessType type, int32 numInputs, int32 numOutputs, buf_t **inputs, buf_t **outputs, int32 sampleFrames)
{
	if(!m_processMem.Good())
	{
		MPT_ASSERT_NOTREACHED();
		return;
	}

	ProcessMsg *processMsg = m_processMem.Data<ProcessMsg>();
	new(processMsg) ProcessMsg{type, numInputs, numOutputs, sampleFrames};

	// Anticipate that many plugins will query the play position in a process call and send it along the process call
	// to save some valuable inter-process calls.
	m_sharedMem->timeInfo = *FromIntPtr<VstTimeInfo>(CVstPlugin::MasterCallBack(&m_sharedMem->effect, audioMasterGetTime, 0, kVstNanosValid | kVstPpqPosValid | kVstTempoValid | kVstBarsValid | kVstCyclePosValid | kVstTimeSigValid | kVstSmpteValid | kVstClockValid, nullptr, 0.0f));

	buf_t *ptr = reinterpret_cast<buf_t *>(processMsg + 1);
	for(int32 i = 0; i < numInputs; i++)
	{
		std::memcpy(ptr, inputs[i], sampleFrames * sizeof(buf_t));
		ptr += sampleFrames;
	}
	// Theoretically, we should memcpy() instead of memset() here in process(), but OpenMPT always clears the output buffer before processing so it doesn't matter.
	memset(ptr, 0, numOutputs * sampleFrames * sizeof(buf_t));

	// In case we called Process() from the GUI thread (panic button or song stop => CSoundFile::SuspendPlugins)
	m_isAudioThread = true;

	m_sigProcessAudio.Send();
	const HANDLE objects[] = {m_sigProcessAudio.confirm, m_sigToHostAudio.send, m_otherProcess};
	DWORD result;
	do
	{
		result = WaitForMultipleObjects(mpt::saturate_cast<DWORD>(std::size(objects)), objects, FALSE, INFINITE);
		if(result == WAIT_OBJECT_0 + 1)
		{
			ParseNextMessage(m_sharedMem->audioThreadToHostMsgID);
			m_sigToHostAudio.Confirm();
		}
	} while(result != WAIT_OBJECT_0 && result != WAIT_OBJECT_0 + 2 && result != WAIT_FAILED);

	m_isAudioThread = false;

	for(int32 i = 0; i < numOutputs; i++)
	{
		//std::memcpy(outputs[i], ptr, sampleFrames * sizeof(buf_t));
		outputs[i] = ptr;  // Exactly what you don't want plugins to do usually (bend your output pointers)... muahahaha!
		ptr += sampleFrames;
	}

	// Did we receive any audioMasterProcessEvents data?
	if(auto *events = m_eventMem.Data<int32>(); events != nullptr && *events != 0)
	{
		std::vector<char> eventCache;
		TranslateBridgeToVstEvents(eventCache, events);
		*events = 0;
		CVstPlugin::MasterCallBack(&m_sharedMem->effect, audioMasterProcessEvents, 0, 0, eventCache.data(), 0.0f);
	}
}


LRESULT CALLBACK BridgeWrapper::WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if(hwnd == m_communicationWindow && wParam < m_plugins.size())
	{
		auto *that = static_cast<BridgeWrapper *>(m_plugins[wParam]);
		if(that != nullptr && uMsg == WM_BRIDGE_MESSAGE_TO_HOST)
		{
			that->ParseNextMessage(static_cast<int>(lParam));
			return WM_BRIDGE_SUCCESS;
		}
	}

	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

#endif  // MPT_WITH_VST


OPENMPT_NAMESPACE_END