@soundor/vst3-host 0.0.0-stage → 0.1.1

package/native/src/HostWindow.h

@@ -0,0 +1,187 @@
+// An SDL window drawing the host interface (HostInterface) around a native view
+// the editor attaches to (EditorArea).
+//
+// In the `host` presentation the editor's area always has the editor's size:
+// resizing or maximizing the window, or opening or closing the panel, changes
+// the stage around it, never the editor, whether or not the editor can be
+// resized. As in the web host, its grip and its own requests can use the stage,
+// and the window never grows for them. The window's minimum keeps room for the
+// editor.
+//
+// On Linux, the `editor` presentation is a bare window that is the editor. Its
+// border asks the editor for each size, and the editor takes the answer at once
+// (VST3 has no call for a shape, so an edge that the answer refuses is asked
+// again, with the other side left to the editor). The window manager owns the
+// window through a drag: the window takes the editor's size once it has stopped.
+//
+// A change of the editor's geometry is presented as one, as a browser's are:
+// where the platform needs it, the window draws the editor's images itself
+// until the change is over (EditorArea's live presentation), and a window
+// manager waits for the frame of a size it asks for (_NET_WM_SYNC_REQUEST).
+// The window and the interface follow the user every frame, with the editor's
+// last image stretched to its new size; the editor is asked for one size at a
+// time, and for another only once it has painted the last.
+//
+// The interface is presented when its drawing changes, never in a loop: a
+// frame is built on input, at the monitor refresh rate while audio plays, and every 100 ms
+// otherwise (values change without input too), and presented only if it
+// differs from the last one.
+#pragma once
+
+#include "EditorArea.h"
+#include "EditorWindow.h"
+#include "HostInterface.h"
+
+#include <array>
+#include <chrono>
+#include <cstdint>
+#include <memory>
+
+struct SDL_Renderer;
+struct SDL_Texture;
+struct SDL_Window;
+union SDL_Event;
+struct ImGuiContext;
+
+namespace soundor::vst3host
+{
+    class HostWindow final : public EditorWindow
+    {
+    public:
+        /** nullptr and `error` when no window can be made (no display). A bare
+            window has no interface: the editor is all of it, its border resizes
+            the editor, and it cannot be maximized or minimized. */
+        static std::unique_ptr<EditorWindow> create(EventLoop& loop, HostModel& model, const std::string& title,
+                                                    int width, int height, bool bare, Callbacks callbacks,
+                                                    std::string& error);
+
+        HostWindow(EventLoop& loop, HostModel& model, bool bare, Callbacks callbacks);
+        ~HostWindow() override;
+        HostWindow(const HostWindow&) = delete;
+        HostWindow& operator=(const HostWindow&) = delete;
+
+        [[nodiscard]] const char* platformType() const override { return area_->platformType(); }
+        [[nodiscard]] void* parentHandle() const override { return area_->handle(); }
+        void setResizable(bool resizable) override;
+        void setContentSize(int width, int height) override;
+        void constrainContentSize(int width, int height) override;
+        void setEditorMinimum(int width, int height) override;
+        void setEditorMaximum(int width, int height) override;
+        [[nodiscard]] std::optional<std::pair<int, int>> editorRoom() const override;
+        void show() override;
+        [[nodiscard]] double scale() const override;
+        [[nodiscard]] const char* presentation() const override { return bare_ ? "editor" : "host"; }
+        [[nodiscard]] std::pair<int, int> windowSize() const override;
+
+        /** Tests check that an idle window draws nothing. */
+        [[nodiscard]] std::optional<uint64_t> interfaceFrames() const override { return presented_; }
+
+    private:
+        bool open(const std::string& title, int width, int height, std::string& error);
+        void pump();
+        void handle(const SDL_Event& event);
+        /** The window's natural size for the editor and the panel. */
+        [[nodiscard]] std::pair<int, int> naturalSize() const;
+        /** What the editor, the dock and the panel take, however short the
+            panel scrolls. */
+        [[nodiscard]] std::pair<int, int> requiredSize() const;
+        void windowResized();
+        /** Maximized or restored since the last frame: the editor follows. */
+        /** The window for the editor and the panel, keeping the space the
+            user made: `extraWidth` more of it for a panel that opened. */
+        void fitWindow(int extraWidth = 0);
+        void applyLimits();
+        void layout();
+        void askWindowSize(int width, int height);
+        /** A bare window's border has changed the editor it is. */
+        void bareWindowResized();
+        /** Gives a bare window the editor's size after a drag has stopped. */
+        void settleWindow(std::chrono::steady_clock::time_point now);
+        /** What the interface takes around the editor: nothing in a bare window. */
+        [[nodiscard]] float paddingSpace() const;
+        [[nodiscard]] float dockHeight() const;
+        [[nodiscard]] float dockSpan() const;
+        /** What the panel takes from the stage now. */
+        [[nodiscard]] float panelSpace() const;
+        void applyScale();
+        void applyRefreshRate();
+        void invalidate(int frames = 2) { pending_ = std::max(pending_, frames); }
+        void render();
+        /** The editor's geometry is changing: presents it live until it stops. */
+        void touchLive();
+        void endLive();
+        /** The editor's size for the window's stage. */
+        [[nodiscard]] std::pair<int, int> stageEditorSize() const;
+        void updateLiveImage();
+
+        EventLoop& loop_;
+        HostModel& model_;
+        Callbacks callbacks_;
+        SDL_Window* window_ = nullptr;
+        SDL_Renderer* renderer_ = nullptr;
+        ImGuiContext* context_ = nullptr;
+        std::unique_ptr<EditorArea> area_;
+        std::unique_ptr<HostInterface> interface_;
+        EventLoop::Id timer_ = 0;
+
+        int editorWidth_ = 0;
+        int editorHeight_ = 0;
+        std::array<int, 4> editorFrame_ {};
+        bool resizable_ = false;
+        bool shown_ = false;
+        bool live_ = false;
+        std::chrono::steady_clock::time_point liveTouched_ {};
+        SDL_Texture* liveTexture_ = nullptr;
+        int liveWidth_ = 0;
+        int liveHeight_ = 0;
+        /** The part of the image that holds the editor's pixels, and where it
+            goes in the window; none for a whole image, which fills the editor. */
+        struct LivePart
+        {
+            float x, y, width, height, u0, v0, u1, v1;
+        };
+        std::optional<LivePart> livePart_;
+        bool livePartial_ = false;
+        bool viewHidden_ = false;
+        /** The image to draw is an older one, not what the view shows. */
+        bool hideViewFirst_ = false;
+        std::chrono::steady_clock::time_point windowResizedAt_ {};
+        int minimumWidth_ = 1;
+        int minimumHeight_ = 1;
+        /** The panel the stage leaves room for: panelOpen_ once the window has
+            taken its width. */
+        bool stagePanelOpen_ = false;
+        std::chrono::steady_clock::time_point stageFollowsAt_ {};
+        /** The user's newest grip drag, for the editor to take when it can. */
+        std::optional<std::pair<int, int>> gripSize_;
+        bool bare_ = false;
+        int maximumWidth_ = 0;
+        int maximumHeight_ = 0;
+        /** A drag has changed a bare window: it takes the editor's size once
+            the drag has stopped. */
+        bool settling_ = false;
+        int settlingAsks_ = 0;
+        /** The bare window's size at the last step of a drag. */
+        std::pair<int, int> draggedSize_ { 0, 0 };
+        /** A size a bare window has asked for and not yet got. */
+        std::optional<std::pair<int, int>> askedSize_;
+        std::chrono::steady_clock::time_point askedUntil_ {};
+        bool panelOpen_ = false;
+        float scale_ = 1;
+        /** The natural size the window was last fitted to. */
+        std::pair<int, int> fitted_ { 0, 0 };
+        /** The window's limits, as last set. */
+        std::pair<int, int> limits_ { 0, 0 };
+        int pending_ = 0;
+        bool forcePresent_ = true;
+        uint64_t lastHash_ = 0;
+        uint64_t presented_ = 0;
+        std::chrono::steady_clock::time_point lastFrame_ {};
+        std::chrono::steady_clock::time_point nextFrame_ {};
+        std::chrono::steady_clock::duration frameInterval_ {};
+        bool closing_ = false;
+        /** False once this window is gone. On macOS, SDL's wait for events runs
+            the main queue's work, which can close the window it is waiting for. */
+        std::shared_ptr<bool> alive_ = std::make_shared<bool>(true);
+    };
+} // namespace soundor::vst3host

package/native/src/Ipc.cpp

@@ -0,0 +1,158 @@
+#include "Ipc.h"
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+
+#ifdef _WIN32
+    #include <windows.h>
+#else
+    #include <unistd.h>
+
+    #include <cerrno>
+#endif
+
+namespace soundor::vst3host
+{
+    void Payload::resize(size_t size)
+    {
+        storage_.assign((size + sizeof(double) - 1) / sizeof(double), 0.0);
+        size_ = size;
+    }
+
+    namespace
+    {
+        uint32_t readU32(const uint8_t* bytes)
+        {
+            return static_cast<uint32_t>(bytes[0]) | (static_cast<uint32_t>(bytes[1]) << 8U)
+                   | (static_cast<uint32_t>(bytes[2]) << 16U) | (static_cast<uint32_t>(bytes[3]) << 24U);
+        }
+
+        void writeU32(uint8_t* bytes, uint32_t value)
+        {
+            bytes[0] = static_cast<uint8_t>(value);
+            bytes[1] = static_cast<uint8_t>(value >> 8U);
+            bytes[2] = static_cast<uint8_t>(value >> 16U);
+            bytes[3] = static_cast<uint8_t>(value >> 24U);
+        }
+    } // namespace
+
+    bool FrameReader::readExact(uint8_t* data, size_t size, bool& end) const
+    {
+        size_t done = 0;
+        while (done < size)
+        {
+#ifdef _WIN32
+            DWORD count = 0;
+            const DWORD chunk = static_cast<DWORD>(std::min<size_t>(size - done, 1U << 30U));
+            if (! ReadFile(reinterpret_cast<HANDLE>(handle_), data + done, chunk, &count, nullptr) || count == 0)
+            {
+                end = done == 0;
+                return false;
+            }
+#else
+            const ssize_t count = ::read(static_cast<int>(handle_), data + done, size - done);
+            if (count < 0 && errno == EINTR)
+                continue;
+            if (count <= 0)
+            {
+                end = done == 0;
+                return false;
+            }
+#endif
+            done += static_cast<size_t>(count);
+        }
+        return true;
+    }
+
+    FrameReader::Status FrameReader::read(Frame& frame, std::string& error)
+    {
+        std::array<uint8_t, frameHeaderBytes> prefix {};
+        bool end = false;
+        if (! readExact(prefix.data(), prefix.size(), end))
+        {
+            if (end)
+                return Status::End;
+            error = "the request stream ended inside a frame header";
+            return Status::Error;
+        }
+        if (readU32(prefix.data()) != frameMagic)
+        {
+            error = "the request stream is not framed (bad magic)";
+            return Status::Error;
+        }
+        const uint32_t headerSize = readU32(prefix.data() + 4);
+        const uint32_t payloadSize = readU32(prefix.data() + 8);
+        if (headerSize > maxHeader_)
+        {
+            error = "a request header of " + std::to_string(headerSize) + " bytes exceeds the limit of "
+                    + std::to_string(maxHeader_);
+            return Status::Error;
+        }
+        if (payloadSize > maxPayload_)
+        {
+            error = "a request payload of " + std::to_string(payloadSize) + " bytes exceeds the limit of "
+                    + std::to_string(maxPayload_);
+            return Status::Error;
+        }
+        std::string header(headerSize, '\0');
+        if (headerSize > 0 && ! readExact(reinterpret_cast<uint8_t*>(header.data()), headerSize, end))
+        {
+            error = "the request stream ended inside a frame";
+            return Status::Error;
+        }
+        frame.payload.resize(payloadSize);
+        if (payloadSize > 0 && ! readExact(frame.payload.data(), payloadSize, end))
+        {
+            error = "the request stream ended inside a frame";
+            return Status::Error;
+        }
+        try
+        {
+            frame.header = Json::parse(header);
+        }
+        catch (const JsonError&)
+        {
+            frame.header = Json();
+        }
+        return Status::Frame;
+    }
+
+    bool FrameWriter::writeAll(const uint8_t* data, size_t size) const
+    {
+        size_t done = 0;
+        while (done < size)
+        {
+#ifdef _WIN32
+            DWORD count = 0;
+            const DWORD chunk = static_cast<DWORD>(std::min<size_t>(size - done, 1U << 30U));
+            if (! WriteFile(reinterpret_cast<HANDLE>(handle_), data + done, chunk, &count, nullptr))
+                return false;
+#else
+            const ssize_t count = ::write(static_cast<int>(handle_), data + done, size - done);
+            if (count < 0 && errno == EINTR)
+                continue;
+            if (count <= 0)
+                return false;
+#endif
+            done += static_cast<size_t>(count);
+        }
+        return true;
+    }
+
+    bool FrameWriter::write(const Json& header, std::span<const uint8_t> payload)
+    {
+        const std::string text = header.dump();
+        std::array<uint8_t, frameHeaderBytes> prefix {};
+        writeU32(prefix.data(), frameMagic);
+        writeU32(prefix.data() + 4, static_cast<uint32_t>(text.size()));
+        writeU32(prefix.data() + 8, static_cast<uint32_t>(payload.size()));
+        const std::scoped_lock lock(mutex_);
+        if (broken_)
+            return false;
+        broken_ = ! writeAll(prefix.data(), prefix.size())
+                  || ! writeAll(reinterpret_cast<const uint8_t*>(text.data()), text.size())
+                  || ! writeAll(payload.data(), payload.size());
+        return ! broken_;
+    }
+} // namespace soundor::vst3host

package/native/src/Ipc.h

@@ -0,0 +1,91 @@
+// Framing of the host's protocol (README, "Protocol"). Each frame is
+//
+//   magic "SVH1" | u32 LE header length | u32 LE payload length | header | payload
+//
+// The header is a UTF-8 JSON object; the payload is raw bytes (audio as
+// little-endian float32, plugin state). Requests arrive on stdin, responses
+// and events leave on the process's original stdout, which Main.cpp moves
+// out of the way of plugins writing to fd 1.
+#pragma once
+
+#include "Json.h"
+
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <span>
+#include <string>
+#include <vector>
+
+namespace soundor::vst3host
+{
+    inline constexpr uint32_t frameMagic = 0x31485653; // "SVH1", little-endian
+    inline constexpr size_t frameHeaderBytes = 12;
+
+    /** A byte buffer whose data is aligned for float and double access. */
+    class Payload
+    {
+    public:
+        Payload() = default;
+        explicit Payload(size_t size) { resize(size); }
+        void resize(size_t size);
+        uint8_t* data() { return storage_.empty() ? nullptr : reinterpret_cast<uint8_t*>(storage_.data()); }
+        const uint8_t* data() const
+        {
+            return storage_.empty() ? nullptr : reinterpret_cast<const uint8_t*>(storage_.data());
+        }
+        size_t size() const { return size_; }
+
+    private:
+        std::vector<double> storage_;
+        size_t size_ = 0;
+    };
+
+    struct Frame
+    {
+        Json header;
+        Payload payload;
+    };
+
+    /** A native file handle: an fd on POSIX, a HANDLE on Windows. */
+    using NativeHandle = intptr_t;
+
+    class FrameReader
+    {
+    public:
+        enum class Status
+        {
+            Frame,
+            End,
+            Error
+        };
+        FrameReader(NativeHandle handle, size_t maxHeader, size_t maxPayload)
+            : handle_(handle), maxHeader_(maxHeader), maxPayload_(maxPayload)
+        {
+        }
+        /** Blocks for the next frame. On Error, `error` says why; the stream
+            cannot be resynchronised afterwards. A header that is not valid
+            JSON still returns a Frame whose header is null. */
+        Status read(Frame& frame, std::string& error);
+
+    private:
+        bool readExact(uint8_t* data, size_t size, bool& end) const;
+        NativeHandle handle_;
+        size_t maxHeader_;
+        size_t maxPayload_;
+    };
+
+    class FrameWriter
+    {
+    public:
+        explicit FrameWriter(NativeHandle handle) : handle_(handle) {}
+        /** Thread-safe; false once the reader has gone. */
+        bool write(const Json& header, std::span<const uint8_t> payload = {});
+
+    private:
+        bool writeAll(const uint8_t* data, size_t size) const;
+        std::mutex mutex_;
+        NativeHandle handle_;
+        bool broken_ = false;
+    };
+} // namespace soundor::vst3host