@soundor/vst3-host 0.0.0-stage → 0.1.1

package/native/src/EditorWindow.h

@@ -0,0 +1,72 @@
+// The native window an editor (IPlugView) is attached to: an X11 window on
+// Linux, an NSWindow on macOS and an HWND on Windows. Sizes are in the
+// view's coordinates: physical pixels on Linux and Windows, points on macOS
+// (IPlugView's convention).
+#pragma once
+
+#include "EventLoop.h"
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace soundor::vst3host
+{
+    class EditorWindow
+    {
+    public:
+        struct Callbacks
+        {
+            /** The user resized the window; the editor gets the new size. */
+            std::function<void(int width, int height)> resized;
+            /** The user closed the window. */
+            std::function<void()> closed;
+            std::function<void(bool focused)> focusChanged;
+            /** Windows and Linux: the monitor's scale changed. */
+            std::function<void(double scale)> scaleChanged;
+        };
+
+        virtual ~EditorWindow() = default;
+
+        /** A window that is the editor alone (the `editor` presentation) on
+            macOS and Windows; nullptr and `error` when none can be made. The
+            host interface's window, and Linux's in either presentation, is a
+            HostWindow. */
+        static std::unique_ptr<EditorWindow> create(EventLoop& loop, const std::string& title, int width, int height,
+                                                    Callbacks callbacks, std::string& error);
+
+        /** The IPlugView platform type and the parent handle to attach to. */
+        [[nodiscard]] virtual const char* platformType() const = 0;
+        [[nodiscard]] virtual void* parentHandle() const = 0;
+
+        virtual void setResizable(bool resizable) = 0;
+        /** Resizes the editor's area to the editor's size, without calling
+            `resized`. */
+        virtual void setContentSize(int width, int height) = 0;
+        /** The smallest size the editor keeps to: the window need not be
+            smaller than what that takes. */
+        virtual void setEditorMinimum(int width, int height) { (void)width, (void)height; }
+        /** The largest editor there is: a window that is the editor need not
+            be larger. */
+        virtual void setEditorMaximum(int width, int height) { (void)width, (void)height; }
+        /** The largest editor the window has room for, where it is not to
+            grow for one (the host presentation, as in the web host): at least
+            the editor's size. */
+        [[nodiscard]] virtual std::optional<std::pair<int, int>> editorRoom() const { return std::nullopt; }
+        /** The editor's limits corrected a size from `resized`. */
+        virtual void constrainContentSize(int width, int height) { setContentSize(width, height); }
+        virtual void show() = 0;
+        /** The platform's scale for this window (1 on macOS, whose views are
+            in points). */
+        [[nodiscard]] virtual double scale() const = 0;
+        /** "editor" (the window is the editor) or "host" (with the host interface). */
+        [[nodiscard]] virtual const char* presentation() const { return "editor"; }
+        /** The window's content size, in the editor's coordinates. */
+        [[nodiscard]] virtual std::pair<int, int> windowSize() const = 0;
+        /** The host interface's frames presented so far; none without it. */
+        [[nodiscard]] virtual std::optional<uint64_t> interfaceFrames() const { return std::nullopt; }
+    };
+} // namespace soundor::vst3host

package/native/src/EditorWindowMac.mm

@@ -0,0 +1,134 @@
+// An NSWindow whose content view hosts the editor. Notifications arrive
+// through block observers: the host registers no Objective-C classes.
+#include "EditorWindow.h"
+
+#import <Cocoa/Cocoa.h>
+
+#include <vector>
+
+namespace soundor::vst3host
+{
+    namespace
+    {
+        class MacEditorWindow final : public EditorWindow
+        {
+        public:
+            MacEditorWindow(EventLoop& loop, const std::string& title, int width, int height, Callbacks callbacks)
+                : loop_(loop), callbacks_(std::move(callbacks))
+            {
+                const NSRect frame = NSMakeRect(0, 0, width, height);
+                window_ = [[NSWindow alloc]
+                    initWithContentRect:frame
+                              styleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskResizable
+                                backing:NSBackingStoreBuffered
+                                  defer:NO];
+                [window_ setReleasedWhenClosed:NO];
+                // It shows the editor at the editor's size: not maximized or
+                // minimized.
+                [window_ setCollectionBehavior:NSWindowCollectionBehaviorFullScreenNone];
+                [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:NO];
+                [window_ setTitle:[NSString stringWithUTF8String:title.c_str()]];
+                content_ = [[NSView alloc] initWithFrame:frame];
+                [window_ setContentView:content_];
+                [window_ center];
+
+                NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
+                auto observe = [&](NSNotificationName name, void (^block)(NSNotification*)) {
+                    observers_.push_back([[center addObserverForName:name object:window_ queue:nil
+                                                          usingBlock:block] retain]);
+                };
+                observe(NSWindowDidResizeNotification, ^(NSNotification*) {
+                  if (ignoreResize_ || ! callbacks_.resized)
+                      return;
+                  const NSSize size = [content_ frame].size;
+                  callbacks_.resized(static_cast<int>(size.width), static_cast<int>(size.height));
+                });
+                observe(NSWindowDidBecomeKeyNotification, ^(NSNotification*) {
+                  if (callbacks_.focusChanged)
+                      callbacks_.focusChanged(true);
+                });
+                observe(NSWindowDidResignKeyNotification, ^(NSNotification*) {
+                  if (callbacks_.focusChanged)
+                      callbacks_.focusChanged(false);
+                });
+                observe(NSWindowWillCloseNotification, ^(NSNotification*) {
+                  if (closing_ || ! callbacks_.closed)
+                      return;
+                  // The callback destroys this window.
+                  loop_.post(callbacks_.closed);
+                });
+            }
+
+            ~MacEditorWindow() override
+            {
+                closing_ = true;
+                for (id observer : observers_)
+                {
+                    [[NSNotificationCenter defaultCenter] removeObserver:observer];
+                    [observer release];
+                }
+                [window_ orderOut:nil];
+                [window_ close];
+                [content_ release];
+                [window_ release];
+            }
+
+            [[nodiscard]] const char* platformType() const override { return "NSView"; }
+            [[nodiscard]] void* parentHandle() const override { return static_cast<void*>(content_); }
+
+            void setResizable(bool resizable) override
+            {
+                NSWindowStyleMask mask = [window_ styleMask];
+                mask = resizable ? (mask | NSWindowStyleMaskResizable) : (mask & ~NSWindowStyleMaskResizable);
+                [window_ setStyleMask:mask];
+                [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:NO];
+            }
+
+            void setContentSize(int width, int height) override
+            {
+                if (windowSize() == std::pair(width, height))
+                    return;
+                ignoreResize_ = true;
+                [window_ setContentSize:NSMakeSize(width, height)];
+                ignoreResize_ = false;
+            }
+
+            void show() override
+            {
+                [window_ makeKeyAndOrderFront:nil];
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+                // Deprecated in macOS 14 for -activate, which 12 and 13 lack.
+                [NSApp activateIgnoringOtherApps:YES];
+#pragma clang diagnostic pop
+            }
+
+            [[nodiscard]] double scale() const override { return 1.0; }
+            [[nodiscard]] std::pair<int, int> windowSize() const override
+            {
+                const NSSize size = [content_ frame].size;
+                return { static_cast<int>(size.width), static_cast<int>(size.height) };
+            }
+
+        private:
+            EventLoop& loop_;
+            Callbacks callbacks_;
+            NSWindow* window_ = nil;
+            NSView* content_ = nil;
+            std::vector<id> observers_;
+            bool ignoreResize_ = false;
+            bool closing_ = false;
+        };
+    } // namespace
+
+    std::unique_ptr<EditorWindow> EditorWindow::create(EventLoop& loop, const std::string& title, int width, int height,
+                                                       Callbacks callbacks, std::string& error)
+    {
+        if (NSApp == nil)
+        {
+            error = "the editor needs UI mode";
+            return nullptr;
+        }
+        return std::make_unique<MacEditorWindow>(loop, title, width, height, std::move(callbacks));
+    }
+} // namespace soundor::vst3host

package/native/src/EditorWindowWindows.cpp

@@ -0,0 +1,148 @@
+#include "EditorWindow.h"
+
+#ifndef NOMINMAX
+    #define NOMINMAX
+#endif
+#include <windows.h>
+
+#include <algorithm>
+#include <string>
+
+namespace soundor::vst3host
+{
+    namespace
+    {
+        std::wstring widen(const std::string& text)
+        {
+            const int size = MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, nullptr, 0);
+            std::wstring result(static_cast<size_t>(std::max(size, 1)), L'\0');
+            MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, result.data(), size);
+            result.resize(static_cast<size_t>(std::max(size - 1, 0)));
+            return result;
+        }
+
+        // It shows the editor at the editor's size: not maximized or minimized.
+        constexpr DWORD resizableStyle = (WS_OVERLAPPEDWINDOW & ~(WS_MINIMIZEBOX | WS_MAXIMIZEBOX)) | WS_CLIPCHILDREN;
+        constexpr DWORD fixedStyle = resizableStyle & ~WS_THICKFRAME;
+
+        class WindowsEditorWindow final : public EditorWindow
+        {
+        public:
+            WindowsEditorWindow(EventLoop& loop, const std::string& title, int width, int height, Callbacks callbacks)
+                : loop_(loop), callbacks_(std::move(callbacks))
+            {
+                static const ATOM windowClass = []
+                {
+                    WNDCLASSEXW description {};
+                    description.cbSize = sizeof description;
+                    description.style = CS_HREDRAW | CS_VREDRAW;
+                    description.lpfnWndProc = &WindowsEditorWindow::windowProc;
+                    description.hInstance = GetModuleHandleW(nullptr);
+                    description.hCursor = LoadCursorW(nullptr, IDC_ARROW);
+                    description.hbrBackground = static_cast<HBRUSH>(GetStockObject(BLACK_BRUSH));
+                    description.lpszClassName = L"SoundorVst3HostEditor";
+                    return RegisterClassExW(&description);
+                }();
+                window_ =
+                    CreateWindowExW(0, MAKEINTATOM(windowClass), widen(title).c_str(), resizableStyle, CW_USEDEFAULT,
+                                    CW_USEDEFAULT, width, height, nullptr, nullptr, GetModuleHandleW(nullptr), nullptr);
+                SetWindowLongPtrW(window_, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
+                setContentSize(width, height);
+            }
+
+            ~WindowsEditorWindow() override
+            {
+                SetWindowLongPtrW(window_, GWLP_USERDATA, 0);
+                DestroyWindow(window_);
+            }
+
+            [[nodiscard]] const char* platformType() const override { return "HWND"; }
+            [[nodiscard]] void* parentHandle() const override { return window_; }
+
+            void setResizable(bool resizable) override
+            {
+                resizable_ = resizable;
+                SetWindowLongPtrW(window_, GWL_STYLE,
+                                  static_cast<LONG_PTR>(resizable ? resizableStyle : fixedStyle)
+                                      | (IsWindowVisible(window_) ? WS_VISIBLE : 0));
+                RECT client {};
+                GetClientRect(window_, &client);
+                setContentSize(client.right - client.left, client.bottom - client.top);
+            }
+
+            void setContentSize(int width, int height) override
+            {
+                RECT rect { 0, 0, width, height };
+                const DWORD style = resizable_ ? resizableStyle : fixedStyle;
+                AdjustWindowRectExForDpi(&rect, style, FALSE, 0, GetDpiForWindow(window_));
+                ignoreResize_ = true;
+                SetWindowPos(window_, nullptr, 0, 0, rect.right - rect.left, rect.bottom - rect.top,
+                             SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
+                ignoreResize_ = false;
+            }
+
+            void show() override
+            {
+                ShowWindow(window_, SW_SHOWNORMAL);
+                SetForegroundWindow(window_);
+            }
+
+            [[nodiscard]] double scale() const override { return static_cast<double>(GetDpiForWindow(window_)) / 96.0; }
+            [[nodiscard]] std::pair<int, int> windowSize() const override
+            {
+                RECT client {};
+                GetClientRect(window_, &client);
+                return { static_cast<int>(client.right - client.left), static_cast<int>(client.bottom - client.top) };
+            }
+
+        private:
+            static LRESULT CALLBACK windowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
+            {
+                auto* self = reinterpret_cast<WindowsEditorWindow*>(GetWindowLongPtrW(window, GWLP_USERDATA));
+                if (self == nullptr)
+                    return DefWindowProcW(window, message, wParam, lParam);
+                switch (message)
+                {
+                    case WM_SIZE:
+                        if (! self->ignoreResize_ && wParam != SIZE_MINIMIZED && self->callbacks_.resized)
+                            self->callbacks_.resized(LOWORD(lParam), HIWORD(lParam));
+                        return 0;
+                    case WM_ACTIVATE:
+                        if (self->callbacks_.focusChanged)
+                            self->callbacks_.focusChanged(LOWORD(wParam) != WA_INACTIVE);
+                        break;
+                    case WM_DPICHANGED:
+                    {
+                        const auto* suggested = reinterpret_cast<const RECT*>(lParam);
+                        SetWindowPos(window, nullptr, suggested->left, suggested->top,
+                                     suggested->right - suggested->left, suggested->bottom - suggested->top,
+                                     SWP_NOZORDER | SWP_NOACTIVATE);
+                        if (self->callbacks_.scaleChanged)
+                            self->callbacks_.scaleChanged(static_cast<double>(HIWORD(wParam)) / 96.0);
+                        return 0;
+                    }
+                    case WM_CLOSE:
+                        // The callback destroys this window.
+                        if (self->callbacks_.closed)
+                            self->loop_.post(self->callbacks_.closed);
+                        return 0;
+                    default:
+                        break;
+                }
+                return DefWindowProcW(window, message, wParam, lParam);
+            }
+
+            EventLoop& loop_;
+            Callbacks callbacks_;
+            HWND window_ = nullptr;
+            bool resizable_ = true;
+            bool ignoreResize_ = false;
+        };
+    } // namespace
+
+    std::unique_ptr<EditorWindow> EditorWindow::create(EventLoop& loop, const std::string& title, int width, int height,
+                                                       Callbacks callbacks, std::string& /*error*/)
+    {
+        return std::make_unique<WindowsEditorWindow>(loop, title, width, height, std::move(callbacks));
+    }
+} // namespace soundor::vst3host

package/native/src/EventLoop.h

@@ -0,0 +1,50 @@
+// The main thread's loop. Every SDK call except process() runs on it, as
+// VST3 requires of the "UI thread"; other threads hand work to it with post().
+//
+// Headless mode creates no window and initializes no video backend, but still
+// runs this loop: plugins post work to their main thread (dispatch's main
+// queue on macOS, window messages on Windows, IRunLoop handlers on Linux).
+#pragma once
+
+#include <functional>
+#include <memory>
+
+namespace soundor::vst3host
+{
+    class EventLoop
+    {
+    public:
+        virtual ~EventLoop() = default;
+
+        /** `ui`: the platform's application object is set up for windows
+            (NSApplication on macOS); otherwise nothing visual is touched. */
+        static std::unique_ptr<EventLoop> create(bool ui);
+
+        /** Runs until quit(). */
+        virtual void run() = 0;
+        /** Main thread only. */
+        virtual void quit() = 0;
+        /** Any thread. Tasks run on the main thread, in order. */
+        virtual void post(std::function<void()> task) = 0;
+
+        using Id = unsigned long;
+        /** A repeating timer on the main thread. Main thread only. */
+        virtual Id addTimer(unsigned milliseconds, std::function<void()> fire) = 0;
+        virtual void removeTimer(Id id) = 0;
+
+#if defined(__APPLE__)
+        /** In UI mode, waits for and dispatches Cocoa's events instead of the
+            loop's own wait (the host interface's SDL window reads them
+            itself); nullptr goes back to the loop's. */
+        virtual void setWaiter(std::function<void(double seconds)> wait) = 0;
+#endif
+
+#if defined(__linux__)
+        // With the timers, Linux::IRunLoop's primitives (HostContext.cpp),
+        // also used by the X11 windows for their display connections. Main
+        // thread only.
+        virtual Id addFd(int fd, std::function<void()> readable) = 0;
+        virtual void removeFd(Id id) = 0;
+#endif
+    };
+} // namespace soundor::vst3host

package/native/src/EventLoopLinux.cpp

@@ -0,0 +1,204 @@
+#include "EventLoop.h"
+
+#include <fcntl.h>
+#include <poll.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <cerrno>
+#include <chrono>
+#include <deque>
+#include <mutex>
+#include <vector>
+
+namespace soundor::vst3host
+{
+    namespace
+    {
+        class LinuxEventLoop final : public EventLoop
+        {
+        public:
+            LinuxEventLoop()
+            {
+                if (pipe2(wake_, O_CLOEXEC | O_NONBLOCK) != 0)
+                    wake_[0] = wake_[1] = -1;
+            }
+
+            ~LinuxEventLoop() override
+            {
+                for (const int fd : wake_)
+                    if (fd >= 0)
+                        close(fd);
+            }
+
+            void run() override
+            {
+                running_ = true;
+                while (running_)
+                {
+                    runTasks();
+                    if (! running_)
+                        break;
+
+                    std::vector<pollfd> fds;
+                    std::vector<Id> ids;
+                    fds.push_back({ wake_[0], POLLIN, 0 });
+                    ids.push_back(0);
+                    for (const auto& handler : fds_)
+                    {
+                        fds.push_back({ handler.fd, POLLIN, 0 });
+                        ids.push_back(handler.id);
+                    }
+
+                    const int ready = poll(fds.data(), fds.size(), timeoutMs());
+                    if (ready < 0 && errno != EINTR)
+                        break;
+                    if (ready > 0)
+                    {
+                        if ((fds[0].revents & POLLIN) != 0)
+                        {
+                            char buffer[64];
+                            while (read(wake_[0], buffer, sizeof buffer) > 0)
+                            {
+                            }
+                        }
+                        for (size_t i = 1; i < fds.size(); ++i)
+                            if ((fds[i].revents & (POLLIN | POLLHUP | POLLERR)) != 0)
+                                fireFd(ids[i]);
+                    }
+                    fireTimers();
+                }
+            }
+
+            void quit() override
+            {
+                running_ = false;
+                wake();
+            }
+
+            void post(std::function<void()> task) override
+            {
+                {
+                    const std::scoped_lock lock(mutex_);
+                    tasks_.push_back(std::move(task));
+                }
+                wake();
+            }
+
+            Id addFd(int fd, std::function<void()> readable) override
+            {
+                const Id id = ++nextId_;
+                fds_.push_back({ id, fd, std::move(readable) });
+                return id;
+            }
+
+            void removeFd(Id id) override
+            {
+                std::erase_if(fds_, [id](const FdHandler& handler) { return handler.id == id; });
+            }
+
+            Id addTimer(unsigned milliseconds, std::function<void()> fire) override
+            {
+                const Id id = ++nextId_;
+                const auto interval = std::chrono::milliseconds(std::max(1U, milliseconds));
+                timers_.push_back({ id, interval, Clock::now() + interval, std::move(fire) });
+                return id;
+            }
+
+            void removeTimer(Id id) override
+            {
+                std::erase_if(timers_, [id](const Timer& timer) { return timer.id == id; });
+            }
+
+        private:
+            using Clock = std::chrono::steady_clock;
+            struct FdHandler
+            {
+                Id id;
+                int fd;
+                std::function<void()> readable;
+            };
+            struct Timer
+            {
+                Id id;
+                Clock::duration interval;
+                Clock::time_point due;
+                std::function<void()> fire;
+            };
+
+            void wake()
+            {
+                if (wake_[1] >= 0)
+                {
+                    const char byte = 1;
+                    [[maybe_unused]] const auto written = write(wake_[1], &byte, 1);
+                }
+            }
+
+            void runTasks()
+            {
+                std::deque<std::function<void()>> tasks;
+                {
+                    const std::scoped_lock lock(mutex_);
+                    tasks.swap(tasks_);
+                }
+                for (auto& task : tasks)
+                    task();
+            }
+
+            [[nodiscard]] int timeoutMs() const
+            {
+                if (timers_.empty())
+                    return -1;
+                const auto now = Clock::now();
+                auto next = timers_.front().due;
+                for (const auto& timer : timers_)
+                    next = std::min(next, timer.due);
+                if (next <= now)
+                    return 0;
+                return static_cast<int>(std::chrono::ceil<std::chrono::milliseconds>(next - now).count());
+            }
+
+            // Handlers may add or remove handlers; each is looked up again.
+            void fireFd(Id id)
+            {
+                const auto it = std::ranges::find(fds_, id, &FdHandler::id);
+                if (it == fds_.end())
+                    return;
+                const auto callback = it->readable;
+                callback();
+            }
+
+            void fireTimers()
+            {
+                const auto now = Clock::now();
+                std::vector<Id> due;
+                for (const auto& timer : timers_)
+                    if (timer.due <= now)
+                        due.push_back(timer.id);
+                for (const Id id : due)
+                {
+                    const auto it = std::ranges::find(timers_, id, &Timer::id);
+                    if (it == timers_.end())
+                        continue;
+                    it->due = now + it->interval;
+                    const auto callback = it->fire;
+                    callback();
+                }
+            }
+
+            int wake_[2] = { -1, -1 };
+            bool running_ = false;
+            std::mutex mutex_;
+            std::deque<std::function<void()>> tasks_;
+            std::vector<FdHandler> fds_;
+            std::vector<Timer> timers_;
+            Id nextId_ = 0;
+        };
+    } // namespace
+
+    std::unique_ptr<EventLoop> EventLoop::create(bool /*ui*/)
+    {
+        return std::make_unique<LinuxEventLoop>();
+    }
+} // namespace soundor::vst3host