mirror of
https://github.com/robbert-vdh/yabridge.git
synced 2026-05-07 03:50:11 +02:00
Robbert van der Helm
596 lines
26 KiB
C++
596 lines
26 KiB
C++
// yabridge: a Wine plugin bridge
|
|
// Copyright (C) 2020-2022 Robbert van der Helm
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#include "clap.h"
|
|
|
|
#include <codecvt>
|
|
#include <locale>
|
|
|
|
#include <clap/plugin-factory.h>
|
|
|
|
// Generated inside of the build directory
|
|
#include <version.h>
|
|
|
|
namespace fs = ghc::filesystem;
|
|
|
|
ClapPluginExtensions::ClapPluginExtensions(const clap_plugin& plugin) noexcept
|
|
: audio_ports(static_cast<const clap_plugin_audio_ports_t*>(
|
|
plugin.get_extension(&plugin, CLAP_EXT_AUDIO_PORTS))),
|
|
note_ports(static_cast<const clap_plugin_note_ports_t*>(
|
|
plugin.get_extension(&plugin, CLAP_EXT_NOTE_PORTS))) {}
|
|
|
|
ClapPluginExtensions::ClapPluginExtensions() noexcept {}
|
|
|
|
clap::plugin::SupportedPluginExtensions ClapPluginExtensions::supported()
|
|
const noexcept {
|
|
return clap::plugin::SupportedPluginExtensions{
|
|
.supports_audio_ports = audio_ports != nullptr,
|
|
.supports_note_ports = note_ports != nullptr};
|
|
}
|
|
|
|
ClapPluginInstance::ClapPluginInstance(
|
|
const clap_plugin* plugin,
|
|
std::unique_ptr<clap_host_proxy> host_proxy) noexcept
|
|
: host_proxy(std::move(host_proxy)),
|
|
plugin((assert(plugin), plugin), plugin->destroy),
|
|
// We may only query the supported extensions after initializing the
|
|
// plugin
|
|
extensions() {}
|
|
|
|
ClapBridge::ClapBridge(MainContext& main_context,
|
|
// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
|
|
std::string plugin_dll_path,
|
|
std::string endpoint_base_dir,
|
|
pid_t parent_pid)
|
|
: HostBridge(main_context, plugin_dll_path, parent_pid),
|
|
logger_(generic_logger_),
|
|
plugin_handle_(LoadLibrary(plugin_dll_path.c_str()), FreeLibrary),
|
|
entry_(plugin_handle_
|
|
? reinterpret_cast<clap_plugin_entry_t*>(
|
|
GetProcAddress(plugin_handle_.get(), "clap_entry"))
|
|
: nullptr,
|
|
[](clap_plugin_entry_t* entry) { entry->deinit(); }),
|
|
sockets_(main_context.context_, endpoint_base_dir, false) {
|
|
if (!plugin_handle_) {
|
|
throw std::runtime_error(
|
|
"Could not load the Windows .clap (.dll) file at '" +
|
|
plugin_dll_path + "'");
|
|
}
|
|
if (!entry_) {
|
|
throw std::runtime_error(
|
|
"" + plugin_dll_path +
|
|
"' does not export the 'clap_entry' entry point.");
|
|
}
|
|
|
|
if (!clap_version_is_compatible(entry_->clap_version)) {
|
|
throw std::runtime_error(
|
|
"" + plugin_dll_path + "' has an incompatible CLAP version (" +
|
|
std::to_string(entry_->clap_version.major) + "." +
|
|
std::to_string(entry_->clap_version.minor) + "." +
|
|
std::to_string(entry_->clap_version.revision) + ").");
|
|
}
|
|
|
|
// CLAP plugins receive the library path in their init function. The problem
|
|
// is that `plugin_dll_path` is a Linux path. This should be fine as all
|
|
// Wine syscalls can work with both Windows and Linux style paths, but if
|
|
// the plugin wants to manipulate the path then this may result in
|
|
// unexpected behavior. Wine can convert these paths for us, but we'd get a
|
|
// `WCHAR*` back which we must first convert back to UTF-8.
|
|
bool init_success;
|
|
WCHAR* dos_plugin_dll_path(wine_get_dos_file_name(plugin_dll_path.c_str()));
|
|
if (dos_plugin_dll_path) {
|
|
static_assert(sizeof(WCHAR) == sizeof(char16_t));
|
|
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>
|
|
converter;
|
|
const std::string converted_plugin_path =
|
|
std::string(converter.to_bytes(std::u16string(
|
|
reinterpret_cast<char16_t*>(dos_plugin_dll_path))));
|
|
|
|
// This function is not optional, but if the plugin somehow does not
|
|
// provide it and we'll call it anyways then the error will be less than
|
|
// obvious
|
|
assert(entry_->init);
|
|
init_success = entry_->init(converted_plugin_path.c_str());
|
|
|
|
// Can't use regular `free()` or `unique_ptr` here
|
|
HeapFree(GetProcessHeap(), 0, dos_plugin_dll_path);
|
|
} else {
|
|
// This should never be hit, but just in case
|
|
init_success = entry_->init(plugin_dll_path.c_str());
|
|
}
|
|
|
|
if (!init_success) {
|
|
// `clap_entry->deinit()` is normally called when `entry_` is dropped,
|
|
// but taht shouldn't happen if the entry point was never initialized.
|
|
[[maybe_unused]] auto _ = entry_.release();
|
|
throw std::runtime_error("'clap_entry->init()' returned false.");
|
|
}
|
|
|
|
sockets_.connect();
|
|
|
|
// Fetch this instance's configuration from the plugin to finish the setup
|
|
// process
|
|
config_ = sockets_.plugin_host_main_thread_callback_.send_message(
|
|
WantsConfiguration{.host_version = yabridge_git_version}, std::nullopt);
|
|
|
|
// Allow this plugin to configure the main context's tick rate
|
|
main_context.update_timer_interval(config_.event_loop_interval());
|
|
}
|
|
|
|
bool ClapBridge::inhibits_event_loop() noexcept {
|
|
std::shared_lock lock(object_instances_mutex_);
|
|
|
|
for (const auto& [instance_id, instance] : object_instances_) {
|
|
if (!instance.is_initialized) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ClapBridge::run() {
|
|
set_realtime_priority(true);
|
|
|
|
sockets_.host_plugin_main_thread_control_.receive_messages(
|
|
std::nullopt,
|
|
overload{
|
|
[&](const WantsConfiguration&) -> WantsConfiguration::Response {
|
|
// FIXME: This overload shouldn't be here, but
|
|
// bitsery simply won't allow us to serialize the
|
|
// variant without it.
|
|
return {};
|
|
},
|
|
[&](const clap::plugin_factory::List&)
|
|
-> clap::plugin_factory::List::Response {
|
|
return main_context_
|
|
.run_in_context([&]() {
|
|
plugin_factory_ =
|
|
static_cast<const clap_plugin_factory_t*>(
|
|
entry_->get_factory(CLAP_PLUGIN_FACTORY_ID));
|
|
if (!plugin_factory_) {
|
|
return clap::plugin_factory::ListResponse{
|
|
.descriptors = std::nullopt};
|
|
}
|
|
|
|
std::vector<clap::plugin::Descriptor> descriptors;
|
|
const uint32_t num_plugins =
|
|
plugin_factory_->get_plugin_count(plugin_factory_);
|
|
for (uint32_t i = 0; i < num_plugins; i++) {
|
|
const clap_plugin_descriptor_t* descriptor =
|
|
plugin_factory_->get_plugin_descriptor(
|
|
plugin_factory_, i);
|
|
if (!descriptor) {
|
|
std::cerr << "Plugin returned a null pointer "
|
|
"for plugin index "
|
|
<< i << "(" << num_plugins
|
|
<< " total), skipping..."
|
|
<< std::endl;
|
|
continue;
|
|
}
|
|
|
|
descriptors.push_back(*descriptor);
|
|
}
|
|
|
|
return clap::plugin_factory::ListResponse{
|
|
.descriptors = descriptors};
|
|
})
|
|
.get();
|
|
},
|
|
[&](clap::plugin_factory::Create& request)
|
|
-> clap::plugin_factory::Create::Response {
|
|
return main_context_
|
|
.run_in_context([&]() {
|
|
// This assertion should never be hit, but you can never
|
|
// be too sure!
|
|
assert(plugin_factory_);
|
|
|
|
// We need the instance ID before the instance exists.
|
|
// If creating the plugin fails then that's no problem
|
|
// since we're using sparse hash maps anyways.
|
|
const size_t instance_id = generate_instance_id();
|
|
auto host_proxy = std::make_unique<clap_host_proxy>(
|
|
*this, instance_id, std::move(request.host));
|
|
|
|
const clap_plugin_t* plugin =
|
|
plugin_factory_->create_plugin(
|
|
plugin_factory_, host_proxy->host_vtable(),
|
|
request.plugin_id.c_str());
|
|
if (plugin) {
|
|
register_plugin_instance(plugin,
|
|
std::move(host_proxy));
|
|
return clap::plugin_factory::CreateResponse{
|
|
.instance_id = instance_id};
|
|
} else {
|
|
return clap::plugin_factory::CreateResponse{
|
|
.instance_id = std::nullopt};
|
|
}
|
|
})
|
|
.get();
|
|
},
|
|
[&](clap::plugin::Init& request) -> clap::plugin::Init::Response {
|
|
const auto& [instance, _] = get_instance(request.instance_id);
|
|
|
|
return main_context_
|
|
.run_in_context([&, plugin = instance.plugin.get(),
|
|
&instance = instance]() {
|
|
// The plugin is allowed to query the same set of
|
|
// extensions from our host proxy that the native host
|
|
// supports
|
|
instance.host_proxy->supported_extensions_ =
|
|
request.supported_host_extensions;
|
|
|
|
const bool result = plugin->init(plugin);
|
|
if (result) {
|
|
// This mimics the same behavior we had to implement
|
|
// for VST2 and VST3. The Win32 message loop is
|
|
// completely blocked while a plugin instance has
|
|
// been created but not yet initialized.
|
|
instance.is_initialized = true;
|
|
|
|
// At this point we should also get the extension
|
|
// pointers for the plugin's supported extensions.
|
|
// In addition we'll send whether or not the plugin
|
|
// supports these extensions as booleans to the
|
|
// native plugin side so we can expose these same
|
|
// extensions to the host.
|
|
instance.extensions = ClapPluginExtensions(*plugin);
|
|
|
|
return clap::plugin::InitResponse{
|
|
.result = result,
|
|
// Similarly, we'll make the plugin's supported
|
|
// extensions available to the host
|
|
.supported_plugin_extensions =
|
|
instance.extensions.supported()};
|
|
} else {
|
|
return clap::plugin::InitResponse{
|
|
.result = result,
|
|
.supported_plugin_extensions = {}};
|
|
}
|
|
})
|
|
.get();
|
|
},
|
|
[&](clap::plugin::Destroy& request)
|
|
-> clap::plugin::Destroy::Response {
|
|
return main_context_
|
|
.run_in_context([&]() {
|
|
// This calls `clap_plugin::destroy()` as part of
|
|
// cleaning up the `unique_ptr` holding the plugin
|
|
// instance pointer
|
|
unregister_plugin_instance(request.instance_id);
|
|
|
|
return Ack{};
|
|
})
|
|
.get();
|
|
},
|
|
[&](clap::plugin::Activate& request)
|
|
-> clap::plugin::Activate::Response {
|
|
const auto& [instance, _] = get_instance(request.instance_id);
|
|
|
|
return main_context_
|
|
.run_in_context([&, plugin = instance.plugin.get()]() {
|
|
const bool result = plugin->activate(
|
|
plugin, request.sample_rate,
|
|
request.min_frames_count, request.max_frames_count);
|
|
|
|
const std::optional<AudioShmBuffer::Config>
|
|
updated_audio_buffers_config =
|
|
setup_shared_audio_buffers(request.instance_id,
|
|
request);
|
|
|
|
return clap::plugin::ActivateResponse{
|
|
.result = result,
|
|
.updated_audio_buffers_config =
|
|
std::move(updated_audio_buffers_config)};
|
|
})
|
|
.get();
|
|
},
|
|
[&](clap::plugin::Deactivate& request)
|
|
-> clap::plugin::Deactivate::Response {
|
|
const auto& [instance, _] = get_instance(request.instance_id);
|
|
|
|
return main_context_
|
|
.run_in_context([&, plugin = instance.plugin.get()]() {
|
|
plugin->deactivate(plugin);
|
|
|
|
return Ack{};
|
|
})
|
|
.get();
|
|
},
|
|
[&](const clap::ext::audio_ports::plugin::Count& request)
|
|
-> clap::ext::audio_ports::plugin::Count::Response {
|
|
const auto& [instance, _] = get_instance(request.instance_id);
|
|
|
|
// We'll ignore the main thread requirement for simple array
|
|
// lookups to avoid the synchronisation costs in code code paths
|
|
return instance.extensions.audio_ports->count(
|
|
instance.plugin.get(), request.is_input);
|
|
},
|
|
[&](const clap::ext::audio_ports::plugin::Get& request)
|
|
-> clap::ext::audio_ports::plugin::Get::Response {
|
|
const auto& [instance, _] = get_instance(request.instance_id);
|
|
|
|
// We'll ignore the main thread requirement for simple array
|
|
// lookups to avoid the synchronisation costs in code code paths
|
|
clap_audio_port_info_t info{};
|
|
if (instance.extensions.audio_ports->get(
|
|
instance.plugin.get(), request.index, request.is_input,
|
|
&info)) {
|
|
return clap::ext::audio_ports::plugin::GetResponse{
|
|
.result = info};
|
|
} else {
|
|
return clap::ext::audio_ports::plugin::GetResponse{
|
|
.result = std::nullopt};
|
|
}
|
|
},
|
|
[&](const clap::ext::note_ports::plugin::Count& request)
|
|
-> clap::ext::note_ports::plugin::Count::Response {
|
|
const auto& [instance, _] = get_instance(request.instance_id);
|
|
|
|
// We'll ignore the main thread requirement for simple array
|
|
// lookups to avoid the synchronisation costs in code code paths
|
|
return instance.extensions.note_ports->count(
|
|
instance.plugin.get(), request.is_input);
|
|
},
|
|
[&](const clap::ext::note_ports::plugin::Get& request)
|
|
-> clap::ext::note_ports::plugin::Get::Response {
|
|
const auto& [instance, _] = get_instance(request.instance_id);
|
|
|
|
// We'll ignore the main thread requirement for simple array
|
|
// lookups to avoid the synchronisation costs in code code paths
|
|
clap_note_port_info_t info{};
|
|
if (instance.extensions.note_ports->get(
|
|
instance.plugin.get(), request.index, request.is_input,
|
|
&info)) {
|
|
return clap::ext::note_ports::plugin::GetResponse{.result =
|
|
info};
|
|
} else {
|
|
return clap::ext::note_ports::plugin::GetResponse{
|
|
.result = std::nullopt};
|
|
}
|
|
},
|
|
});
|
|
}
|
|
|
|
// TODO: Implement this
|
|
// bool ClapBridge::maybe_resize_editor(size_t instance_id,
|
|
// const Steinberg::ViewRect& new_size) {
|
|
// const auto& [instance, _] = get_instance(instance_id);
|
|
|
|
// if (instance.editor) {
|
|
// instance.editor->resize(new_size.getWidth(), new_size.getHeight());
|
|
// return true;
|
|
// } else {
|
|
// return false;
|
|
// }
|
|
// }
|
|
|
|
void ClapBridge::close_sockets() {
|
|
sockets_.close();
|
|
}
|
|
|
|
std::pair<ClapPluginInstance&, std::shared_lock<std::shared_mutex>>
|
|
ClapBridge::get_instance(size_t instance_id) noexcept {
|
|
std::shared_lock lock(object_instances_mutex_);
|
|
|
|
return std::pair<ClapPluginInstance&, std::shared_lock<std::shared_mutex>>(
|
|
object_instances_.at(instance_id), std::move(lock));
|
|
}
|
|
|
|
size_t ClapBridge::generate_instance_id() noexcept {
|
|
return current_instance_id_.fetch_add(1);
|
|
}
|
|
|
|
std::optional<AudioShmBuffer::Config> ClapBridge::setup_shared_audio_buffers(
|
|
size_t instance_id,
|
|
const clap::plugin::Activate& activate_request) {
|
|
const auto& [instance, _] = get_instance(instance_id);
|
|
|
|
const clap_plugin_t* plugin = instance.plugin.get();
|
|
const clap_plugin_audio_ports_t* audio_ports =
|
|
instance.extensions.audio_ports;
|
|
if (!audio_ports) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
// We'll query the plugin for its audio port layouts, and then create
|
|
// calculate the offsets in a large memory buffer for the different audio
|
|
// channels. The offsets for each audio channel are in bytes because CLAP
|
|
// allows the host to send mixed 32-bit and 64-bit audio if the plugin
|
|
// advertises supporting 64-bit audio. Because of that we'll allocate enough
|
|
// space for double precision audio when the port supports it, and then
|
|
// we'll simply only use the first half of that space if the host sends
|
|
// 32-bit audio.
|
|
uint32_t current_offset = 0;
|
|
auto create_bus_offsets = [&](bool is_input) {
|
|
const uint32_t num_ports = audio_ports->count(plugin, is_input);
|
|
|
|
std::vector<std::vector<uint32_t>> offsets(num_ports);
|
|
for (uint32_t port = 0; port < num_ports; port++) {
|
|
clap_audio_port_info_t info{};
|
|
assert(audio_ports->get(plugin, port, is_input, &info));
|
|
|
|
// If the audio port supports 64-bit audio, then we should allocate
|
|
// enough memory for that
|
|
const size_t sample_size =
|
|
(info.flags & CLAP_AUDIO_PORT_SUPPORTS_64BITS) != 0
|
|
? sizeof(double)
|
|
: sizeof(float);
|
|
|
|
offsets[port].resize(info.channel_count);
|
|
for (size_t channel = 0; channel < info.channel_count; channel++) {
|
|
offsets[port][channel] = current_offset;
|
|
current_offset +=
|
|
activate_request.max_frames_count * sample_size;
|
|
}
|
|
}
|
|
|
|
return offsets;
|
|
};
|
|
|
|
// Creating the audio buffer offsets for every channel in every bus will
|
|
// advance `current_offset` to keep pointing to the starting position for
|
|
// the next channel
|
|
const auto input_bus_offsets = create_bus_offsets(true);
|
|
const auto output_bus_offsets = create_bus_offsets(false);
|
|
const uint32_t buffer_size = current_offset;
|
|
|
|
// If this function has been called previously and the size did not change,
|
|
// then we should not do any work
|
|
if (instance.process_buffers &&
|
|
instance.process_buffers->config_.size == buffer_size) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
// We'll set up these shared memory buffers on the Wine side first, and then
|
|
// when this request returns we'll do the same thing on the native plugin
|
|
// side
|
|
AudioShmBuffer::Config buffer_config{
|
|
.name = sockets_.base_dir_.filename().string() + "-" +
|
|
std::to_string(instance_id),
|
|
.size = buffer_size,
|
|
.input_offsets = std::move(input_bus_offsets),
|
|
.output_offsets = std::move(output_bus_offsets)};
|
|
if (!instance.process_buffers) {
|
|
instance.process_buffers.emplace(buffer_config);
|
|
} else {
|
|
instance.process_buffers->resize(buffer_config);
|
|
}
|
|
|
|
// After setting up the shared memory buffer, we need to create a vector of
|
|
// channel audio pointers for every bus. These will then be assigned to the
|
|
// `AudioBusBuffers` objects in the `ClapProcess` struct in
|
|
// `ClapProcess::reconstruct()` before passing the reconstructed process
|
|
// data to `clap_plugin::process()`.
|
|
auto set_port_pointers =
|
|
[&, &process_buffers =
|
|
instance.process_buffers]<std::invocable<uint32_t, uint32_t> F>(
|
|
std::vector<std::vector<void*>>& port_pointers,
|
|
const std::vector<std::vector<uint32_t>>& offsets,
|
|
F&& get_channel_pointer) {
|
|
port_pointers.resize(offsets.size());
|
|
for (size_t port = 0; port < offsets.size(); port++) {
|
|
port_pointers[port].resize(offsets[port].size());
|
|
for (size_t channel = 0; channel < offsets[port].size();
|
|
channel++) {
|
|
port_pointers[port][channel] =
|
|
get_channel_pointer(port, channel);
|
|
}
|
|
}
|
|
};
|
|
|
|
set_port_pointers(instance.process_buffers_input_pointers,
|
|
instance.process_buffers->config_.input_offsets,
|
|
[&process_buffers = instance.process_buffers](
|
|
uint32_t port, uint32_t channel) {
|
|
// This can be treated as either a `double*` or a
|
|
// `float*` depending on what the port supports and
|
|
// what the host gives us
|
|
return process_buffers->input_channel_ptr<void>(
|
|
port, channel);
|
|
});
|
|
set_port_pointers(instance.process_buffers_output_pointers,
|
|
instance.process_buffers->config_.output_offsets,
|
|
[&process_buffers = instance.process_buffers](
|
|
uint32_t port, uint32_t channel) {
|
|
return process_buffers->output_channel_ptr<void>(
|
|
port, channel);
|
|
});
|
|
|
|
return buffer_config;
|
|
}
|
|
|
|
void ClapBridge::register_plugin_instance(
|
|
const clap_plugin* plugin,
|
|
std::unique_ptr<clap_host_proxy> host_proxy) {
|
|
std::unique_lock lock(object_instances_mutex_);
|
|
|
|
assert(plugin);
|
|
assert(host_proxy);
|
|
|
|
// This instance ID has already been generated because the host proxy has to
|
|
// be created before the plugin instance
|
|
const size_t instance_id = host_proxy->owner_instance_id();
|
|
object_instances_.emplace(
|
|
instance_id, ClapPluginInstance(plugin, std::move(host_proxy)));
|
|
|
|
// Every plugin instance gets its own audio thread
|
|
std::promise<void> socket_listening_latch;
|
|
object_instances_.at(instance_id).audio_thread_handler =
|
|
Win32Thread([&, instance_id]() {
|
|
set_realtime_priority(true);
|
|
|
|
// XXX: Like with VST2 worker threads, when using plugin groups the
|
|
// thread names from different plugins will clash. Not a huge
|
|
// deal probably, since duplicate thread names are still more
|
|
// useful than no thread names.
|
|
const std::string thread_name =
|
|
"audio-" + std::to_string(instance_id);
|
|
pthread_setname_np(pthread_self(), thread_name.c_str());
|
|
|
|
sockets_.add_audio_thread_and_listen(
|
|
instance_id, socket_listening_latch,
|
|
overload{
|
|
[&](const clap::plugin::StartProcessing& request)
|
|
-> clap::plugin::StartProcessing::Response {
|
|
const auto& [instance, _] =
|
|
get_instance(request.instance_id);
|
|
|
|
return instance.plugin->start_processing(
|
|
instance.plugin.get());
|
|
},
|
|
[&](const clap::plugin::StopProcessing& request)
|
|
-> clap::plugin::StopProcessing::Response {
|
|
const auto& [instance, _] =
|
|
get_instance(request.instance_id);
|
|
|
|
instance.plugin->stop_processing(instance.plugin.get());
|
|
|
|
return Ack{};
|
|
},
|
|
[&](const clap::plugin::Reset& request)
|
|
-> clap::plugin::Reset::Response {
|
|
const auto& [instance, _] =
|
|
get_instance(request.instance_id);
|
|
|
|
instance.plugin->reset(instance.plugin.get());
|
|
|
|
return Ack{};
|
|
},
|
|
});
|
|
});
|
|
|
|
// Wait for the new socket to be listening on before continuing. Otherwise
|
|
// the native plugin may try to connect to it before our thread is up and
|
|
// running.
|
|
socket_listening_latch.get_future().wait();
|
|
}
|
|
|
|
void ClapBridge::unregister_plugin_instance(size_t instance_id) {
|
|
sockets_.remove_audio_thread(instance_id);
|
|
|
|
// Remove the instance from within the main IO context so
|
|
// removing it doesn't interfere with the Win32 message loop
|
|
// NOTE: This will implicitly run `clap_plugin::destroy()` as part of the
|
|
// `unique_ptr`'s cleanup
|
|
main_context_
|
|
.run_in_context([&, instance_id]() -> void {
|
|
std::unique_lock lock(object_instances_mutex_);
|
|
object_instances_.erase(instance_id);
|
|
})
|
|
.wait();
|
|
}
|