VST hard realtime fix and improvement

vst/SfizzVstEditor.cpp

@@ -199,7 +199,7 @@ void SfizzVstEditor::loadSfzFile(const std::string& filePath)
 
     msg->setMessageID("LoadSfz");
     Vst::IAttributeList* attr = msg->getAttributes();
-    attr->setString("File", Steinberg::String(filePath.c_str()).text());
+    attr->setBinary("File", filePath.data(), filePath.size());
     ctl->sendMessage(msg);
     msg->release();
 

vst/SfizzVstProcessor.cpp

@@ -21,7 +21,7 @@ constexpr int fastRound(T x)
 }
 
 SfizzVstProcessor::SfizzVstProcessor()
-    : _fifoToWorker(1024)
+    : _fifoToWorker(64 * 1024)
 {
     setControllerClass(SfizzVstController::cid);
 }
@@ -119,14 +119,6 @@ tresult PLUGIN_API SfizzVstProcessor::setActive(TBool state)
 
         _fileChangePeriod = static_cast<uint32>(processSetup.sampleRate);
 
-        if (!_msgCheckShouldReload) {
-            auto msg = IPtr<Vst::IMessage>::adopt(allocateMessage());
-            if (!msg)
-                return kResultFalse;
-            msg->setMessageID("CheckShouldReload");
-            _msgCheckShouldReload = msg;
-        }
-
         _workRunning = true;
         _worker = std::thread([this]() { doBackgroundWork(); });
     } else {
@@ -183,11 +175,8 @@ tresult PLUGIN_API SfizzVstProcessor::process(Vst::ProcessData& data)
     _fileChangeCounter += numFrames;
     if (_fileChangeCounter > _fileChangePeriod) {
         _fileChangeCounter %= _fileChangePeriod;
-        Vst::IMessage* msg = _msgCheckShouldReload.get();
+        if (writeWorkerMessage("CheckShouldReload", nullptr, 0))
-        if (_fifoToWorker.push(msg)) {
-            msg->addRef();
             _semaToWorker.post();
-        }
     }
 
     return kResultTrue;
@@ -214,47 +203,26 @@ void SfizzVstProcessor::processParameterChanges(Vst::IParameterChanges& pc)
             break;
         case kPidNumVoices:
             if (pointCount > 0 && vq->getPoint(pointCount - 1, sampleOffset, value) == kResultTrue) {
-                Vst::IMessage* msg = allocateMessage();
+                int32 data = static_cast<int32>(kParamNumVoicesRange.denormalize(value));
-                if (!msg)
+                _state.numVoices = data;
-                    break;
+                if (writeWorkerMessage("SetNumVoices", &data, sizeof(data)))
-                msg->setMessageID("SetNumVoices");
+                    _semaToWorker.post();
-                Vst::IAttributeList* attr = msg->getAttributes();
-                attr->setInt("NumVoices", static_cast<Steinberg::int64>(kParamNumVoicesRange.denormalize(value)));
-                if (!_fifoToWorker.push(msg)) {
-                    msg->release();
-                    break;
-                }
-                _semaToWorker.post();
             }
             break;
         case kPidOversampling:
             if (pointCount > 0 && vq->getPoint(pointCount - 1, sampleOffset, value) == kResultTrue) {
-                Vst::IMessage* msg = allocateMessage();
+                int32 data = static_cast<int32>(kParamOversamplingRange.denormalize(value));
-                if (!msg)
+                _state.oversamplingLog2 = data;
-                    break;
+                if (writeWorkerMessage("SetOversampling", &data, sizeof(data)))
-                msg->setMessageID("SetOversampling");
+                    _semaToWorker.post();
-                Vst::IAttributeList* attr = msg->getAttributes();
-                attr->setInt("Oversampling", static_cast<Steinberg::int64>(kParamOversamplingRange.denormalize(value)));
-                if (!_fifoToWorker.push(msg)) {
-                    msg->release();
-                    break;
-                }
-                _semaToWorker.post();
             }
             break;
         case kPidPreloadSize:
             if (pointCount > 0 && vq->getPoint(pointCount - 1, sampleOffset, value) == kResultTrue) {
-                Vst::IMessage* msg = allocateMessage();
+                int32 data = static_cast<int32>(kParamPreloadSizeRange.denormalize(value));
-                if (!msg)
+                _state.preloadSize = data;
-                    break;
+                if (writeWorkerMessage("SetPreloadSize", &data, sizeof(data)))
-                msg->setMessageID("SetPreloadSize");
+                    _semaToWorker.post();
-                Vst::IAttributeList* attr = msg->getAttributes();
-                attr->setInt("PreloadSize", static_cast<Steinberg::int64>(kParamPreloadSizeRange.denormalize(value)));
-                if (!_fifoToWorker.push(msg)) {
-                    msg->release();
-                    break;
-                }
-                _semaToWorker.post();
             }
             break;
         }
@@ -335,17 +303,29 @@ int SfizzVstProcessor::convertVelocityFromFloat(float x)
 
 tresult PLUGIN_API SfizzVstProcessor::notify(Vst::IMessage* message)
 {
+    // Note(jpc) this notification is not necessarily handled by the RT thread
+
     tresult result = AudioEffect::notify(message);
     if (result != kResultFalse)
         return result;
 
-    if (!_fifoToWorker.push(message))
+    const char* id = message->getMessageID();
-        return kOutOfMemory;
+    Vst::IAttributeList* attr = message->getAttributes();
 
-    message->addRef();
+    if (!std::strcmp(id, "LoadSfz")) {
-    _semaToWorker.post();
+        const void* data = nullptr;
+        uint32 size = 0;
+        result = attr->getBinary("File", data, size);
 
-    return kResultTrue;
+        if (result != kResultTrue)
+            return result;
+
+        std::lock_guard<std::mutex> lock(_processMutex);
+        _state.sfzFile.assign(static_cast<const char *>(data), size);
+        _synth->loadSfzFile(_state.sfzFile);
+    }
+
+    return result;
 }
 
 FUnknown* SfizzVstProcessor::createInstance(void*)
@@ -355,61 +335,38 @@ FUnknown* SfizzVstProcessor::createInstance(void*)
 
 void SfizzVstProcessor::doBackgroundWork()
 {
-    constexpr uint32 maxPathLen = 32768;
-
     for (;;) {
         _semaToWorker.wait();
 
         if (!_workRunning)
             break;
 
-        Vst::IMessage* msg;
+        RTMessagePtr msg = readWorkerMessage();
-        if (!_fifoToWorker.pop(msg)) {
+        if (!msg) {
             fprintf(stderr, "[Sfizz] message synchronization error in worker\n");
             std::abort();
         }
 
-        const char* id = msg->getMessageID();
+        const char* id = msg->type;
-        Vst::IAttributeList* attr = msg->getAttributes();
 
-        if (!std::strcmp(id, "LoadSfz")) {
+        if (!std::strcmp(id, "SetNumVoices")) {
-            std::vector<Vst::TChar> path(maxPathLen + 1);
+            int32 value = *msg->payload<int32>();
-            if (attr->getString("File", path.data(), maxPathLen) == kResultTrue) {
+            _synth->setNumVoices(value);
-                std::lock_guard<std::mutex> lock(_processMutex);
-                _state.sfzFile = Steinberg::String(path.data()).text8();
-                _synth->loadSfzFile(_state.sfzFile);
-            }
-        }
-        else if (!std::strcmp(id, "SetNumVoices")) {
-            int64 value;
-            if (attr->getInt("NumVoices", value) == kResultTrue) {
-                _state.numVoices = value;
-                _synth->setNumVoices(value);
-            }
         }
         else if (!std::strcmp(id, "SetOversampling")) {
-            int64 value;
+            int32 value = *msg->payload<int32>();
-            if (attr->getInt("Oversampling", value) == kResultTrue) {
+            _synth->setOversamplingFactor(1 << value);
-                _state.oversamplingLog2 = value;
-                _synth->setOversamplingFactor(1 << value);
-            }
         }
         else if (!std::strcmp(id, "SetPreloadSize")) {
-            int64 value;
+            int32 value = *msg->payload<int32>();
-            if (attr->getInt("PreloadSize", value) == kResultTrue) {
+            _synth->setPreloadSize(value);
-                _state.preloadSize = value;
-                _synth->setPreloadSize(value);
-            }
         }
         else if (!std::strcmp(id, "CheckShouldReload")) {
             if (_synth->shouldReloadFile()) {
                 fprintf(stderr, "[Sfizz] file has changed, reloading\n");
-                std::lock_guard<std::mutex> lock(_processMutex);
                 _synth->loadSfzFile(_state.sfzFile);
             }
         }
-
-        msg->release();
     }
 }
 
@@ -423,15 +380,61 @@ void SfizzVstProcessor::stopBackgroundWork()
     _worker.join();
 
     while (_semaToWorker.try_wait()) {
-        Vst::IMessage* msg;
+        if (!discardWorkerMessage()) {
-        if (!_fifoToWorker.pop(msg)) {
             fprintf(stderr, "[Sfizz] message synchronization error in processor\n");
             std::abort();
         }
-        msg->release();
     }
 }
 
+bool SfizzVstProcessor::writeWorkerMessage(const char* type, const void* data, uintptr_t size)
+{
+    RTMessage header;
+    header.type = type;
+    header.size = size;
+
+    if (_fifoToWorker.size_free() < sizeof(header) + size)
+        return false;
+
+    _fifoToWorker.put(header);
+    _fifoToWorker.put(static_cast<const uint8*>(data), size);
+    return true;
+}
+
+SfizzVstProcessor::RTMessagePtr SfizzVstProcessor::readWorkerMessage()
+{
+    RTMessage header;
+
+    if (!_fifoToWorker.peek(header))
+        return nullptr;
+    if (_fifoToWorker.size_used() < sizeof(header) + header.size)
+        return nullptr;
+
+    RTMessagePtr msg { reinterpret_cast<RTMessage*>(std::malloc(sizeof(header) + header.size)) };
+    if (!msg)
+        throw std::bad_alloc();
+
+    msg->type = header.type;
+    msg->size = header.size;
+    _fifoToWorker.discard(sizeof(header));
+    _fifoToWorker.get(const_cast<char*>(msg->payload<char>()), header.size);
+
+    return msg;
+}
+
+bool SfizzVstProcessor::discardWorkerMessage()
+{
+    RTMessage header;
+
+    if (!_fifoToWorker.peek(header))
+        return false;
+    if (_fifoToWorker.size_used() < sizeof(header) + header.size)
+        return false;
+
+    _fifoToWorker.discard(sizeof(header) + header.size);
+    return true;
+}
+
 /*
   Note(jpc) Generated at random with uuidgen.
   Can't find docs on it... maybe it's to register somewhere?

vst/SfizzVstProcessor.h

@@ -7,12 +7,13 @@
 #pragma once
 #include "SfizzVstState.h"
 #include "RTSemaphore.h"
+#include "ring_buffer/ring_buffer.h"
 #include "public.sdk/source/vst/vstaudioeffect.h"
-#include "public.sdk/source/vst/utility/ringbuffer.h"
 #include <sfizz.hpp>
 #include <thread>
 #include <mutex>
 #include <memory>
+#include <cstdlib>
 
 using namespace Steinberg;
 
@@ -51,16 +52,40 @@ private:
     // worker and thread sync
     std::thread _worker;
     volatile bool _workRunning = false;
-    Steinberg::OneReaderOneWriter::RingBuffer<Vst::IMessage*> _fifoToWorker;
+    Ring_Buffer _fifoToWorker;
     RTSemaphore _semaToWorker;
     std::mutex _processMutex;
 
     // file modification periodic checker
     uint32 _fileChangeCounter = 0;
     uint32 _fileChangePeriod = 0;
-    IPtr<Vst::IMessage> _msgCheckShouldReload;
+
+    // messaging
+    struct RTMessage {
+        const char* type;
+        uintptr_t size;
+        // 32-bit aligned data after header
+        template <class T> const T* payload() const;
+    };
+    struct RTMessageDelete {
+        void operator()(RTMessage* x) const noexcept { std::free(x); }
+    };
+    typedef std::unique_ptr<RTMessage, RTMessageDelete> RTMessagePtr;
 
     // worker
     void doBackgroundWork();
     void stopBackgroundWork();
+    // writer
+    bool writeWorkerMessage(const char* type, const void* data, uintptr_t size);
+    // reader
+    RTMessagePtr readWorkerMessage();
+    bool discardWorkerMessage();
 };
+
+//------------------------------------------------------------------------------
+
+template <class T> const T* SfizzVstProcessor::RTMessage::payload() const
+{
+    return reinterpret_cast<const T*>(
+        reinterpret_cast<const uint8*>(this) + sizeof(*this));
+}

vst/SfizzVstState.h

@@ -31,6 +31,8 @@ enum {
 
 class SfizzVstState {
 public:
+    SfizzVstState() { sfzFile.reserve(8192); }
+
     std::string sfzFile;
     float volume = 0;
     int32 numVoices = 64;