vanja/yabridge
1
0
Fork 0
mirror of https://github.com/robbert-vdh/yabridge.git synced 2026-06-11 06:42:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

Significantly clean up mutual recursion workaround

Browse Source 
This has much fewer moving parts, and it's probably more understandable.
There was also a race condition in the previous implementation, so
there's that.
This commit is contained in:
Robbert van der Helm
2020-12-23 15:31:32 +01:00
parent eae77d4dbf
commit 7a55fc3ec0
5 changed files with 146 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/wine-host/bridges/vst3-impls/plug-frame-proxy.cpp
+5 -74
View File
@@ -47,80 +47,11 @@ Vst3PlugFrameProxyImpl::resizeView(Steinberg::IPlugView* /*view*/,
// assume `view` is the `IPlugView*` returned by the last call to
// `IEditController::createView()`
// HACK: This ia bit of a weird one and requires special handling. A
// plugin will call this function from the Win32 message loop so
// the call blocks the loop. The host will then check with the
// plugin if it can actually resize itself to `*newSize`, and it
// will then call `IPlugView::onSize()` with the new size. The
// issue is that the `IPlugView::onSize()` call also has to be
// called from within the UI thread, but that thread is currently
// being blocked by the call to this function.
// As a workaround, we'll send the message for the call to
// `IPlugFrame::resizeView()` on another thread. We then wait for
// either that request to finish immediately (meaning the host
// hasn't resized the window), or for `IPlugView::onSize()` to be
// called by the host. If the host does call `IPlugView::onSize()`
// while the other thread is handling `IPlugFrame::resizeView()`,
// then we'll awaken this thread using a condition variable so we
// can do the actual call to `IPlugView::onSize()` from here, from
// within the Win32 loop.
// TODO: Can we someone use Boost.Asio strands to make this cleaner?
{
std::lock_guard lock(on_size_interrupt_mutex);
on_size_interrupt_waiting = true;
on_size_interrupt.reset();
on_size_interrupt_result.reset();
}
std::promise<tresult> resize_result_promise{};
std::future<tresult> resize_result_future =
resize_result_promise.get_future();
Win32Thread resize_thread([&]() {
const tresult result = bridge.send_message(YaPlugFrame::ResizeView{
.owner_instance_id = owner_instance_id(),
.new_size = *newSize});
resize_result_promise.set_value(result);
{
std::lock_guard lock(on_size_interrupt_mutex);
if (BOOST_LIKELY(!on_size_interrupt_waiting)) {
return;
}
// If the call to `IPlugFrame::resizeView()` finish without the
// host calling `IPlugView::onSize()` (e.g. when the call
// failed), then we'll have to manually unblock the thread below
// by providing a noop function.
on_size_interrupt = []() { return Steinberg::kResultOk; };
}
on_size_interrupt_cv.notify_one();
// We don't need this result value, but we should still wait for
// it
std::unique_lock lock(on_size_interrupt_mutex);
on_size_interrupt_cv.wait(
lock, [&]() { return on_size_interrupt_result.has_value(); });
});
// Wait for `IPlugView::onSize()` to be called by the host and handle
// the call here on this thread, or wait for the call to
// `IPlugFrame::resizeView()` in the above thread to finish. In the last
// case we'll execute a noop function.
std::unique_lock lock(on_size_interrupt_mutex);
on_size_interrupt_cv.wait(
lock, [&]() { return on_size_interrupt.has_value(); });
// When we get a function through one of the two above means, we'll
// store the result and then awake the calling thread again so it can
// access the result
on_size_interrupt_result = (*on_size_interrupt)();
on_size_interrupt_waiting = false;
lock.unlock();
on_size_interrupt_cv.notify_one();
return resize_result_future.get();
// We have to use this special sending function here so we can handle
// calls to `IPlugView::onSize()` from this same thread (the UI thread).
// See the docstring for more information.
return bridge.send_mutually_recursive_message(YaPlugFrame::ResizeView{
.owner_instance_id = owner_instance_id(), .new_size = *newSize});
} else {
std::cerr
<< "WARNING: Null pointer passed to 'IPlugFrame::resizeView()'"
src/wine-host/bridges/vst3-impls/plug-frame-proxy.h
-48
View File
@@ -30,58 +30,10 @@ class Vst3PlugFrameProxyImpl : public Vst3PlugFrameProxy {
tresult PLUGIN_API queryInterface(const Steinberg::TUID _iid,
void** obj) override;
/**
* This is needed to be able to handle a call to `IPlugView::onSize()` from
* the UI thread while the plugin is currently calling
* `IPlugFrame::resizeView()` from that same thread.. This is probably the
* hackiest (and most error prone, probably) part of this VST3
* implementation. The details on how this works and why it is necessary are
* explained in the comment in `YaPlugFrameProxyImpl::resizeView()`.
*
* If there is currently a call to `resizeView()` being processed, then this
* will run `on_size` from the same thread that's currently processing a
* call to `resizeView()` and return the result from the function call.
* Otherwise this will return a nullopt and `on_size` should be passed to
* `main_context.run_in_context<tresult>()`.
*/
template <typename F>
std::optional<tresult> maybe_run_on_size_from_ui_thread(F on_size) {
{
std::lock_guard lock(on_size_interrupt_mutex);
if (!on_size_interrupt_waiting) {
return std::nullopt;
}
on_size_interrupt = std::move(on_size);
}
on_size_interrupt_cv.notify_one();
// Since `on_size` is run from another thread, we now have to wait to be
// woken up again when the result is ready
std::unique_lock lock(on_size_interrupt_mutex);
on_size_interrupt_cv.wait(
lock, [&]() { return on_size_interrupt_result.has_value(); });
return *on_size_interrupt_result;
}
// From `IPlugFrame`
tresult PLUGIN_API resizeView(Steinberg::IPlugView* view,
Steinberg::ViewRect* newSize) override;
private:
Vst3Bridge& bridge;
/**
* A function that will be used to run `IPlugView::onSize()` on the thread
* that originally called `IPlugFrame::resizeView()` to work around a Win32
* limitation, along with its result, and whether or not we're currently
* waiting for this function to be provided by some other thread. See the
* comment in `onSize()` for more information.
*/
bool on_size_interrupt_waiting = false;
std::optional<fu2::unique_function<tresult()>> on_size_interrupt;
std::optional<tresult> on_size_interrupt_result;
std::condition_variable on_size_interrupt_cv;
std::mutex on_size_interrupt_mutex;
};