From cead56c9aae548781dfe0fcb00b565b3ea58121e Mon Sep 17 00:00:00 2001
From: Robbert van der Helm <mail@robbertvanderhelm.nl>
Date: Tue, 13 Sep 2022 18:28:30 +0200
Subject: [PATCH] Skip main thread requirement in array lookups

This should be fine, right? We'll do it everywhere else, but especially
for parameters this is going to be very costly and may thus increase
plugin startup time by a noticeable amount if we spool every individual
call to the main thread.
---
 src/wine-host/bridges/clap.cpp | 76 ++++++++++++++--------------------
 1 file changed, 32 insertions(+), 44 deletions(-)

diff --git a/src/wine-host/bridges/clap.cpp b/src/wine-host/bridges/clap.cpp
index 94977d1b..8fd15921 100644
--- a/src/wine-host/bridges/clap.cpp
+++ b/src/wine-host/bridges/clap.cpp
@@ -313,65 +313,53 @@ void ClapBridge::run() {
                 -> clap::ext::audio_ports::plugin::Count::Response {
                 const auto& [instance, _] = get_instance(request.instance_id);
 
-                return main_context_
-                    .run_in_context(
-                        [&, plugin = instance.plugin.get(),
-                         audio_ports = instance.extensions.audio_ports]() {
-                            return audio_ports->count(plugin, request.is_input);
-                        })
-                    .get();
+                // 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);
 
-                return main_context_
-                    .run_in_context([&, plugin = instance.plugin.get(),
-                                     audio_ports =
-                                         instance.extensions.audio_ports]() {
-                        clap_audio_port_info_t info{};
-                        if (audio_ports->get(plugin, 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};
-                        }
-                    })
-                    .get();
+                // 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);
 
-                return main_context_
-                    .run_in_context(
-                        [&, plugin = instance.plugin.get(),
-                         note_ports = instance.extensions.note_ports]() {
-                            return note_ports->count(plugin, request.is_input);
-                        })
-                    .get();
+                // 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);
 
-                return main_context_
-                    .run_in_context([&, plugin = instance.plugin.get(),
-                                     note_ports =
-                                         instance.extensions.note_ports]() {
-                        clap_note_port_info_t info{};
-                        if (note_ports->get(plugin, 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};
-                        }
-                    })
-                    .get();
+                // 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};
+                }
             },
         });
 }