@soundor/vst3-host 0.0.0-stage → 0.1.1

package/native/src/EventLoopMac.mm

@@ -0,0 +1,146 @@
+#include "EventLoop.h"
+
+#import <Cocoa/Cocoa.h>
+
+#include <algorithm>
+#include <map>
+#include <memory>
+
+namespace soundor::vst3host
+{
+    namespace
+    {
+        // Work is posted to the main dispatch queue, which the main run loop
+        // drains in both modes. Headless mode never touches NSApplication.
+        class MacEventLoop final : public EventLoop
+        {
+        public:
+            explicit MacEventLoop(bool ui) : ui_(ui)
+            {
+                if (ui_)
+                {
+                    [NSApplication sharedApplication];
+                    [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
+                    [NSApp finishLaunching];
+                }
+                else
+                {
+                    // A run loop without a source returns at once; this timer
+                    // keeps CFRunLoopRunInMode waiting for posted work.
+                    keepAlive_ = CFRunLoopTimerCreate(
+                        nullptr, CFAbsoluteTimeGetCurrent() + 1e9, 1e9, 0, 0, [](CFRunLoopTimerRef, void*) {}, nullptr);
+                    CFRunLoopAddTimer(CFRunLoopGetMain(), keepAlive_, kCFRunLoopCommonModes);
+                }
+            }
+
+            ~MacEventLoop() override
+            {
+                for (auto& [id, timer] : timers_)
+                {
+                    CFRunLoopTimerInvalidate(timer->timer);
+                    CFRelease(timer->timer);
+                }
+                if (keepAlive_ != nullptr)
+                {
+                    CFRunLoopTimerInvalidate(keepAlive_);
+                    CFRelease(keepAlive_);
+                }
+            }
+
+            void run() override
+            {
+                running_ = true;
+                while (running_)
+                {
+                    @autoreleasepool
+                    {
+                        if (ui_ && waiter_)
+                        {
+                            const auto wait = waiter_;
+                            wait(0.25);
+                        }
+                        else if (ui_)
+                        {
+                            NSEvent* event = [NSApp nextEventMatchingMask:NSEventMaskAny
+                                                                untilDate:[NSDate dateWithTimeIntervalSinceNow:0.25]
+                                                                   inMode:NSDefaultRunLoopMode
+                                                                  dequeue:YES];
+                            if (event != nil)
+                            {
+                                [NSApp sendEvent:event];
+                                [NSApp updateWindows];
+                            }
+                        }
+                        else
+                            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.25, true);
+                    }
+                }
+            }
+
+            void quit() override { running_ = false; }
+
+            void post(std::function<void()> task) override
+            {
+                auto* heap = new std::function<void()>(std::move(task));
+                dispatch_async(dispatch_get_main_queue(), ^{
+                  (*heap)();
+                  delete heap;
+                });
+                CFRunLoopWakeUp(CFRunLoopGetMain());
+            }
+
+            Id addTimer(unsigned milliseconds, std::function<void()> fire) override
+            {
+                const Id id = ++nextId_;
+                auto timer = std::make_unique<Timer>();
+                timer->fire = std::move(fire);
+                const double interval = std::max(1U, milliseconds) / 1000.0;
+                CFRunLoopTimerContext context {};
+                context.info = timer.get();
+                timer->timer = CFRunLoopTimerCreate(
+                    nullptr, CFAbsoluteTimeGetCurrent() + interval, interval, 0, 0,
+                    [](CFRunLoopTimerRef, void* info)
+                    {
+                        // A copy: the callback may remove this timer.
+                        const auto fire = static_cast<Timer*>(info)->fire;
+                        fire();
+                    },
+                    &context);
+                CFRunLoopAddTimer(CFRunLoopGetMain(), timer->timer, kCFRunLoopCommonModes);
+                timers_.emplace(id, std::move(timer));
+                return id;
+            }
+
+            void removeTimer(Id id) override
+            {
+                const auto it = timers_.find(id);
+                if (it == timers_.end())
+                    return;
+                CFRunLoopTimerInvalidate(it->second->timer);
+                CFRelease(it->second->timer);
+                timers_.erase(it);
+            }
+
+            void setWaiter(std::function<void(double seconds)> wait) override { waiter_ = std::move(wait); }
+
+        private:
+            struct Timer
+            {
+                CFRunLoopTimerRef timer = nullptr;
+                std::function<void()> fire;
+            };
+
+            bool ui_;
+            std::function<void(double seconds)> waiter_;
+            std::map<Id, std::unique_ptr<Timer>> timers_;
+            Id nextId_ = 0;
+            bool running_ = false;
+            CFRunLoopTimerRef keepAlive_ = nullptr;
+        };
+    } // namespace
+
+    std::unique_ptr<EventLoop> EventLoop::create(bool ui)
+    {
+        return std::make_unique<MacEventLoop>(ui);
+    }
+} // namespace soundor::vst3host

package/native/src/EventLoopWindows.cpp

@@ -0,0 +1,132 @@
+#include "EventLoop.h"
+
+#include <algorithm>
+#include <deque>
+#include <map>
+#include <mutex>
+
+#ifndef NOMINMAX
+    #define NOMINMAX
+#endif
+#include <windows.h>
+
+namespace soundor::vst3host
+{
+    namespace
+    {
+        constexpr UINT runTasksMessage = WM_APP + 1;
+
+        // Posted work goes through a message-only window rather than thread
+        // messages, which modal loops (a window being dragged or resized)
+        // would drop. Headless mode creates nothing visible.
+        class WindowsEventLoop final : public EventLoop
+        {
+        public:
+            WindowsEventLoop()
+            {
+                WNDCLASSEXW windowClass {};
+                windowClass.cbSize = sizeof windowClass;
+                windowClass.lpfnWndProc = &WindowsEventLoop::windowProc;
+                windowClass.hInstance = GetModuleHandleW(nullptr);
+                windowClass.lpszClassName = L"SoundorVst3HostMessages";
+                RegisterClassExW(&windowClass);
+                window_ = CreateWindowExW(0, windowClass.lpszClassName, L"", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr,
+                                          windowClass.hInstance, nullptr);
+                SetWindowLongPtrW(window_, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
+            }
+
+            ~WindowsEventLoop() override
+            {
+                if (window_ != nullptr)
+                    DestroyWindow(window_);
+            }
+
+            void run() override
+            {
+                running_ = true;
+                MSG message {};
+                while (running_ && GetMessageW(&message, nullptr, 0, 0) > 0)
+                {
+                    TranslateMessage(&message);
+                    DispatchMessageW(&message);
+                }
+            }
+
+            void quit() override
+            {
+                running_ = false;
+                PostMessageW(window_, WM_NULL, 0, 0);
+            }
+
+            void post(std::function<void()> task) override
+            {
+                {
+                    const std::scoped_lock lock(mutex_);
+                    tasks_.push_back(std::move(task));
+                }
+                PostMessageW(window_, runTasksMessage, 0, 0);
+            }
+
+            Id addTimer(unsigned milliseconds, std::function<void()> fire) override
+            {
+                const Id id = ++nextId_;
+                timers_.emplace(id, std::move(fire));
+                SetTimer(window_, static_cast<UINT_PTR>(id), std::max<UINT>(USER_TIMER_MINIMUM, milliseconds), nullptr);
+                return id;
+            }
+
+            void removeTimer(Id id) override
+            {
+                KillTimer(window_, static_cast<UINT_PTR>(id));
+                timers_.erase(id);
+            }
+
+        private:
+            static LRESULT CALLBACK windowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
+            {
+                auto* self = reinterpret_cast<WindowsEventLoop*>(GetWindowLongPtrW(window, GWLP_USERDATA));
+                if (message == runTasksMessage)
+                {
+                    if (self != nullptr)
+                        self->runTasks();
+                    return 0;
+                }
+                if (message == WM_TIMER && self != nullptr)
+                {
+                    const auto it = self->timers_.find(static_cast<Id>(wParam));
+                    if (it != self->timers_.end())
+                    {
+                        // A copy: the callback may remove this timer.
+                        const auto fire = it->second;
+                        fire();
+                    }
+                    return 0;
+                }
+                return DefWindowProcW(window, message, wParam, lParam);
+            }
+
+            void runTasks()
+            {
+                std::deque<std::function<void()>> tasks;
+                {
+                    const std::scoped_lock lock(mutex_);
+                    tasks.swap(tasks_);
+                }
+                for (auto& task : tasks)
+                    task();
+            }
+
+            HWND window_ = nullptr;
+            bool running_ = false;
+            std::mutex mutex_;
+            std::deque<std::function<void()>> tasks_;
+            std::map<Id, std::function<void()>> timers_;
+            Id nextId_ = 0;
+        };
+    } // namespace
+
+    std::unique_ptr<EventLoop> EventLoop::create(bool /*ui*/)
+    {
+        return std::make_unique<WindowsEventLoop>();
+    }
+} // namespace soundor::vst3host

package/native/src/HostContext.cpp

@@ -0,0 +1,217 @@
+#include "HostContext.h"
+
+#include "pluginterfaces/base/ustring.h"
+
+#if defined(__linux__)
+    #include <sys/socket.h>
+    #include <sys/un.h>
+
+    #include <cstddef>
+    #include <string_view>
+#endif
+
+namespace soundor::vst3host
+{
+#if defined(__linux__)
+    namespace
+    {
+        constexpr unsigned xRecheckMilliseconds = 16;
+
+        bool isXConnection(int fd)
+        {
+            sockaddr_un address {};
+            socklen_t size = sizeof address;
+            if (getpeername(fd, reinterpret_cast<sockaddr*>(&address), &size) != 0 || address.sun_family != AF_UNIX
+                || size <= offsetof(sockaddr_un, sun_path))
+                return false;
+            // Abstract sockets start with a NUL.
+            const std::string_view path(address.sun_path, size - offsetof(sockaddr_un, sun_path));
+            return path.find("/.X11-unix/") != std::string_view::npos;
+        }
+    } // namespace
+
+    // A handler that unregisters itself while it runs may drop the last other
+    // reference. It is released at once when it unregisters, never on a later
+    // turn: JUCE's handlers do not count references, and can be gone by then.
+    void RunLoop::fireFd(Linux::IEventHandler* handler, Linux::FileDescriptor fd)
+    {
+        const IPtr<Linux::IEventHandler> alive(handler);
+        handler->onFDIsSet(fd);
+    }
+
+    tresult PLUGIN_API RunLoop::registerEventHandler(Linux::IEventHandler* handler, Linux::FileDescriptor fd)
+    {
+        if (handler == nullptr)
+            return kInvalidArgument;
+        handler->addRef();
+        const auto id = loop_.addFd(fd, [handler, fd] { fireFd(handler, fd); });
+        handlers_.emplace(handler, id);
+        // Xlib reads whatever is on its connection during any round trip into a
+        // queue of its own, and then the connection has nothing to read: an
+        // event that arrived during one (a click) would wait for the next. So
+        // an X connection's handler is asked to look again, every frame. Only
+        // those: they must drain that queue anyway, and do not block with
+        // nothing there, as a handler of any other descriptor might.
+        if (isXConnection(fd))
+            rechecks_.emplace(handler, loop_.addTimer(xRecheckMilliseconds, [handler, fd] { fireFd(handler, fd); }));
+        return kResultTrue;
+    }
+
+    tresult PLUGIN_API RunLoop::unregisterEventHandler(Linux::IEventHandler* handler)
+    {
+        const auto [first, last] = handlers_.equal_range(handler);
+        if (first == last)
+            return kInvalidArgument;
+        const auto [recheck, lastRecheck] = rechecks_.equal_range(handler);
+        for (auto it = recheck; it != lastRecheck; ++it)
+            loop_.removeTimer(it->second);
+        rechecks_.erase(recheck, lastRecheck);
+        for (auto it = first; it != last; ++it)
+        {
+            loop_.removeFd(it->second);
+            handler->release();
+        }
+        handlers_.erase(first, last);
+        return kResultTrue;
+    }
+
+    tresult PLUGIN_API RunLoop::registerTimer(Linux::ITimerHandler* handler, Linux::TimerInterval milliseconds)
+    {
+        if (handler == nullptr)
+            return kInvalidArgument;
+        handler->addRef();
+        const auto id = loop_.addTimer(static_cast<unsigned>(milliseconds),
+                                       [handler]
+                                       {
+                                           const IPtr<Linux::ITimerHandler> alive(handler);
+                                           handler->onTimer();
+                                       });
+        timers_.emplace(handler, id);
+        return kResultTrue;
+    }
+
+    tresult PLUGIN_API RunLoop::unregisterTimer(Linux::ITimerHandler* handler)
+    {
+        const auto [first, last] = timers_.equal_range(handler);
+        if (first == last)
+            return kInvalidArgument;
+        for (auto it = first; it != last; ++it)
+        {
+            loop_.removeTimer(it->second);
+            handler->release();
+        }
+        timers_.erase(first, last);
+        return kResultTrue;
+    }
+
+    void RunLoop::clear()
+    {
+        // The module is about to go: release now, not on a later turn.
+        for (const auto& [handler, id] : rechecks_)
+            loop_.removeTimer(id);
+        rechecks_.clear();
+        for (const auto& [handler, id] : handlers_)
+        {
+            loop_.removeFd(id);
+            handler->release();
+        }
+        for (const auto& [handler, id] : timers_)
+        {
+            loop_.removeTimer(id);
+            handler->release();
+        }
+        handlers_.clear();
+        timers_.clear();
+    }
+#endif
+
+    tresult PLUGIN_API HostApplication::getName(Vst::String128 name)
+    {
+        UString(name, 128).fromAscii("Soundor VST3 Host");
+        return kResultOk;
+    }
+
+    tresult PLUGIN_API HostApplication::queryInterface(const TUID iid, void** obj)
+    {
+#if defined(__linux__)
+        if (runLoop_ != nullptr && FUnknownPrivate::iidEqual(iid, Linux::IRunLoop::iid))
+            return runLoop_->queryInterface(iid, obj);
+#endif
+        return Vst::HostApplication::queryInterface(iid, obj);
+    }
+
+    tresult PLUGIN_API ComponentHandler::beginEdit(Vst::ParamID id)
+    {
+        listener_.beginEdit(id);
+        return kResultOk;
+    }
+
+    tresult PLUGIN_API ComponentHandler::performEdit(Vst::ParamID id, Vst::ParamValue valueNormalized)
+    {
+        listener_.performEdit(id, valueNormalized);
+        return kResultOk;
+    }
+
+    tresult PLUGIN_API ComponentHandler::endEdit(Vst::ParamID id)
+    {
+        listener_.endEdit(id);
+        return kResultOk;
+    }
+
+    tresult PLUGIN_API ComponentHandler::restartComponent(int32 flags)
+    {
+        listener_.restartComponent(flags);
+        return kResultOk;
+    }
+
+    tresult PLUGIN_API ComponentHandler::setDirty(TBool state)
+    {
+        listener_.setDirty(state != 0);
+        return kResultOk;
+    }
+
+    tresult PLUGIN_API ComponentHandler::requestOpenEditor(FIDString name)
+    {
+        if (name == nullptr || std::string_view(name) != Vst::ViewType::kEditor)
+            return kResultFalse;
+        listener_.requestOpenEditor();
+        return kResultOk;
+    }
+
+    tresult PLUGIN_API PlugFrame::resizeView(IPlugView* view, ViewRect* newSize)
+    {
+        if (view == nullptr || newSize == nullptr)
+            return kInvalidArgument;
+        return listener_.resizeView(view, newSize) ? kResultTrue : kResultFalse;
+    }
+
+#if defined(__linux__)
+    namespace
+    {
+        IPtr<Linux::IRunLoop> runLoopOf(FUnknown* object)
+        {
+            return U::cast<Linux::IRunLoop>(object);
+        }
+    } // namespace
+
+    tresult PLUGIN_API PlugFrame::registerEventHandler(Linux::IEventHandler* handler, Linux::FileDescriptor fd)
+    {
+        return runLoopOf(runLoop_)->registerEventHandler(handler, fd);
+    }
+
+    tresult PLUGIN_API PlugFrame::unregisterEventHandler(Linux::IEventHandler* handler)
+    {
+        return runLoopOf(runLoop_)->unregisterEventHandler(handler);
+    }
+
+    tresult PLUGIN_API PlugFrame::registerTimer(Linux::ITimerHandler* handler, Linux::TimerInterval milliseconds)
+    {
+        return runLoopOf(runLoop_)->registerTimer(handler, milliseconds);
+    }
+
+    tresult PLUGIN_API PlugFrame::unregisterTimer(Linux::ITimerHandler* handler)
+    {
+        return runLoopOf(runLoop_)->unregisterTimer(handler);
+    }
+#endif
+} // namespace soundor::vst3host

package/native/src/HostContext.h

@@ -0,0 +1,116 @@
+// The host's side of VST3: what a plugin receives as its host context
+// (IHostApplication, and on Linux IRunLoop), as its controller's component
+// handler, and as its editor's frame.
+#pragma once
+
+#include "EventLoop.h"
+#include "pluginterfaces/base/funknownimpl.h"
+#include "pluginterfaces/gui/iplugview.h"
+#include "pluginterfaces/vst/ivsteditcontroller.h"
+#include "public.sdk/source/vst/hosting/hostclasses.h"
+
+#include <map>
+#include <vector>
+
+namespace soundor::vst3host
+{
+    using namespace Steinberg;
+
+#if defined(__linux__)
+    /** Linux::IRunLoop over the main thread's EventLoop. A handler is held
+        while it runs, and released as soon as it unregisters. */
+    class RunLoop final : public U::Implements<U::Directly<Linux::IRunLoop>>
+    {
+    public:
+        explicit RunLoop(EventLoop& loop) : loop_(loop) {}
+        ~RunLoop() override { clear(); }
+
+        tresult PLUGIN_API registerEventHandler(Linux::IEventHandler* handler, Linux::FileDescriptor fd) override;
+        tresult PLUGIN_API unregisterEventHandler(Linux::IEventHandler* handler) override;
+        tresult PLUGIN_API registerTimer(Linux::ITimerHandler* handler, Linux::TimerInterval milliseconds) override;
+        tresult PLUGIN_API unregisterTimer(Linux::ITimerHandler* handler) override;
+
+        /** Drops every registration: before a plugin's module is unloaded. */
+        void clear();
+
+    private:
+        static void fireFd(Linux::IEventHandler* handler, Linux::FileDescriptor fd);
+
+        EventLoop& loop_;
+        std::multimap<Linux::IEventHandler*, EventLoop::Id> handlers_;
+        /** The timers that ask handlers of X connections to look again. */
+        std::multimap<Linux::IEventHandler*, EventLoop::Id> rechecks_;
+        std::multimap<Linux::ITimerHandler*, EventLoop::Id> timers_;
+    };
+#endif
+
+    /** IHostApplication (and IPlugInterfaceSupport), plus IRunLoop on Linux,
+        which plugins may ask their host context for even without an editor. */
+    class HostApplication final : public Vst::HostApplication
+    {
+    public:
+        explicit HostApplication(FUnknown* runLoop) : runLoop_(runLoop) {}
+        tresult PLUGIN_API getName(Vst::String128 name) override;
+        tresult PLUGIN_API queryInterface(const TUID iid, void** obj) override;
+
+    private:
+        [[maybe_unused]] FUnknown* runLoop_; // Linux only
+    };
+
+    /** What the plugin's controller and editor ask of the host. */
+    class HostListener
+    {
+    public:
+        virtual ~HostListener() = default;
+        virtual void beginEdit(Vst::ParamID id) = 0;
+        virtual void performEdit(Vst::ParamID id, Vst::ParamValue value) = 0;
+        virtual void endEdit(Vst::ParamID id) = 0;
+        virtual void restartComponent(int32 flags) = 0;
+        virtual void setDirty(bool dirty) = 0;
+        virtual void requestOpenEditor() = 0;
+        /** IPlugFrame::resizeView. */
+        virtual bool resizeView(IPlugView* view, ViewRect* size) = 0;
+    };
+
+    class ComponentHandler final : public U::Implements<U::Directly<Vst::IComponentHandler, Vst::IComponentHandler2>>
+    {
+    public:
+        explicit ComponentHandler(HostListener& listener) : listener_(listener) {}
+
+        tresult PLUGIN_API beginEdit(Vst::ParamID id) override;
+        tresult PLUGIN_API performEdit(Vst::ParamID id, Vst::ParamValue valueNormalized) override;
+        tresult PLUGIN_API endEdit(Vst::ParamID id) override;
+        tresult PLUGIN_API restartComponent(int32 flags) override;
+
+        tresult PLUGIN_API setDirty(TBool state) override;
+        tresult PLUGIN_API requestOpenEditor(FIDString name) override;
+        tresult PLUGIN_API startGroupEdit() override { return kResultOk; }
+        tresult PLUGIN_API finishGroupEdit() override { return kResultOk; }
+
+    private:
+        HostListener& listener_;
+    };
+
+#if defined(__linux__)
+    class PlugFrame final : public U::Implements<U::Directly<IPlugFrame, Linux::IRunLoop>>
+#else
+    class PlugFrame final : public U::Implements<U::Directly<IPlugFrame>>
+#endif
+    {
+    public:
+        PlugFrame(HostListener& listener, FUnknown* runLoop) : listener_(listener), runLoop_(runLoop) {}
+
+        tresult PLUGIN_API resizeView(IPlugView* view, ViewRect* newSize) override;
+
+#if defined(__linux__)
+        tresult PLUGIN_API registerEventHandler(Linux::IEventHandler* handler, Linux::FileDescriptor fd) override;
+        tresult PLUGIN_API unregisterEventHandler(Linux::IEventHandler* handler) override;
+        tresult PLUGIN_API registerTimer(Linux::ITimerHandler* handler, Linux::TimerInterval milliseconds) override;
+        tresult PLUGIN_API unregisterTimer(Linux::ITimerHandler* handler) override;
+#endif
+
+    private:
+        HostListener& listener_;
+        [[maybe_unused]] FUnknown* runLoop_; // Linux only
+    };
+} // namespace soundor::vst3host