Out-of-process rebuild: Add Helper/HelperPluginHost.cpp — full implementation

Source/Helper/HelperPluginHost.cpp

@@ -0,0 +1,299 @@
+#include "HelperPluginHost.h"
+#include "../Shared/Constants.h"
+#include <juce_audio_basics/juce_audio_basics.h>
+
+HelperPluginHost::HelperPluginHost()
+{
+    #if JUCE_PLUGINHOST_VST3
+    formatManager.addFormat(new juce::VST3PluginFormat());
+    #endif
+    #if JUCE_PLUGINHOST_AU
+    formatManager.addFormat(new juce::AudioUnitPluginFormat());
+    #endif
+}
+
+HelperPluginHost::~HelperPluginHost()
+{
+    stopProcessing();
+    hideGui();
+    unloadPlugin();
+}
+
+bool HelperPluginHost::loadPlugin(const juce::String& path, double sampleRate, int blockSize)
+{
+    unloadPlugin();
+
+    currentSampleRate = sampleRate;
+    currentBlockSize = blockSize;
+
+    juce::File pluginFile(path);
+    if (!pluginFile.exists())
+        return false;
+
+    juce::OwnedArray<juce::PluginDescription> typesFound;
+
+    for (int i = 0; i < formatManager.getNumFormats(); ++i)
+    {
+        auto* format = formatManager.getFormat(i);
+        bool isVST3 = pluginFile.getFileExtension() == ".vst3";
+        bool isAU = pluginFile.getFileExtension() == ".component";
+
+        if (isVST3 && format->getName() != "VST3") continue;
+        if (isAU && format->getName() != "AudioUnit") continue;
+
+        format->findAllTypesForFile(typesFound, pluginFile.getFullPathName());
+        if (typesFound.size() > 0)
+            break;
+    }
+
+    if (typesFound.isEmpty())
+        return false;
+
+    juce::String errorMessage;
+    plugin = formatManager.createPluginInstance(*typesFound[0], sampleRate, blockSize, errorMessage);
+
+    if (plugin == nullptr)
+    {
+        DBG("HelperPluginHost: Failed to create plugin: " + errorMessage);
+        return false;
+    }
+
+    plugin->enableAllBuses();
+
+    auto layout = juce::AudioProcessor::BusesLayout();
+    layout.inputBuses.add(juce::AudioChannelSet::stereo());
+    layout.outputBuses.add(juce::AudioChannelSet::stereo());
+
+    if (plugin->checkBusesLayoutSupported(layout))
+        plugin->setBusesLayout(layout);
+
+    plugin->prepareToPlay(sampleRate, blockSize);
+
+    DBG("HelperPluginHost: Loaded " + getPluginName() + " (" + juce::String(getParameterCount()) + " params)");
+    return true;
+}
+
+void HelperPluginHost::unloadPlugin()
+{
+    hideGui();
+    if (plugin)
+    {
+        plugin->releaseResources();
+        plugin.reset();
+    }
+}
+
+juce::String HelperPluginHost::getPluginName() const
+{
+    return plugin ? plugin->getName() : juce::String();
+}
+
+int HelperPluginHost::getParameterCount() const
+{
+    return plugin ? plugin->getParameters().size() : 0;
+}
+
+void HelperPluginHost::setSharedAudio(SharedAudioBuffer* shm, SharedSemaphore* inSem, SharedSemaphore* outSem)
+{
+    sharedAudio = shm;
+    inputSem = inSem;
+    outputSem = outSem;
+}
+
+void HelperPluginHost::startProcessing()
+{
+    if (processing.load()) return;
+    processing.store(true);
+
+    audioThread = std::thread([this]() { audioProcessingLoop(); });
+}
+
+void HelperPluginHost::stopProcessing()
+{
+    processing.store(false);
+    if (inputSem) inputSem->signal(); // wake thread so it can exit
+    if (audioThread.joinable())
+        audioThread.join();
+}
+
+void HelperPluginHost::audioProcessingLoop()
+{
+    // Set thread to realtime priority
+    juce::Thread::setCurrentThreadPriority(10);
+
+    while (processing.load())
+    {
+        // Wait for parent to signal input is ready
+        if (!inputSem->wait(100))
+            continue; // timeout — check if still processing
+
+        if (!processing.load()) break;
+        if (!plugin || !sharedAudio) continue;
+
+        auto* header = sharedAudio->getHeader();
+        int numChannels = header->numChannels.load();
+        int blockSize = header->blockSize.load();
+
+        // Read input from shared memory into local buffer
+        juce::AudioBuffer<float> buffer(numChannels, blockSize);
+        float* channelPtrs[2] = { buffer.getWritePointer(0),
+                                   numChannels > 1 ? buffer.getWritePointer(1) : nullptr };
+        sharedAudio->readInput(channelPtrs, numChannels, blockSize);
+
+        // Process
+        juce::MidiBuffer midi;
+        plugin->processBlock(buffer, midi);
+
+        // Write output to shared memory
+        const float* constPtrs[2] = { buffer.getReadPointer(0),
+                                       numChannels > 1 ? buffer.getReadPointer(1) : nullptr };
+        sharedAudio->writeOutput(constPtrs, numChannels, blockSize);
+
+        // Signal parent that output is ready
+        header->state.store(kStateOutputReady);
+        outputSem->signal();
+    }
+}
+
+// --- Parameters ---
+
+std::vector<HelperPluginHost::ParamInfo> HelperPluginHost::searchParams(const juce::String& keyword) const
+{
+    std::vector<ParamInfo> results;
+    if (!plugin) return results;
+
+    auto& params = plugin->getParameters();
+    auto keywordLower = keyword.toLowerCase();
+
+    for (int i = 0; i < params.size(); ++i)
+    {
+        auto* param = params[i];
+        auto name = param->getName(128);
+
+        if (name.toLowerCase().contains(keywordLower))
+        {
+            ParamInfo info;
+            info.index = i;
+            info.name = name;
+            info.value = param->getValue();
+            info.displayText = param->getText(param->getValue(), 64);
+
+            if (auto* hosted = dynamic_cast<juce::AudioPluginInstance::HostedParameter*>(param))
+                info.id = hosted->getParameterID();
+            else
+                info.id = juce::String(i);
+
+            results.push_back(info);
+            if (results.size() >= PluginBridgeConstants::kMaxParamResults)
+                break;
+        }
+    }
+
+    return results;
+}
+
+std::vector<std::pair<int, float>> HelperPluginHost::getParams(const std::vector<int>& ids) const
+{
+    std::vector<std::pair<int, float>> results;
+    if (!plugin) return results;
+
+    auto& params = plugin->getParameters();
+    for (int idx : ids)
+    {
+        if (idx >= 0 && idx < params.size())
+            results.push_back({idx, params[idx]->getValue()});
+    }
+    return results;
+}
+
+bool HelperPluginHost::setParams(const std::map<int, float>& values)
+{
+    if (!plugin) return false;
+
+    auto& params = plugin->getParameters();
+    for (auto& [idx, val] : values)
+    {
+        if (idx >= 0 && idx < params.size())
+        {
+            auto* param = params[idx];
+            param->beginChangeGesture();
+            param->setValueNotifyingHost(juce::jlimit(0.0f, 1.0f, val));
+            param->endChangeGesture();
+        }
+    }
+    return true;
+}
+
+// --- GUI ---
+
+void HelperPluginHost::showGui()
+{
+    if (!plugin || !plugin->hasEditor()) return;
+    if (guiWindow) return; // already showing
+
+    juce::MessageManager::callAsync([this]()
+    {
+        if (!plugin) return;
+
+        auto* editor = plugin->createEditor();
+        if (!editor) return;
+
+        guiWindow = std::make_unique<juce::DocumentWindow>(
+            plugin->getName(),
+            juce::Colour(0xff1a1a2e),
+            juce::DocumentWindow::closeButton | juce::DocumentWindow::minimiseButton);
+
+        guiWindow->setContentOwned(editor, true);
+        guiWindow->setResizable(true, true);
+        guiWindow->centreWithSize(editor->getWidth(), editor->getHeight());
+        guiWindow->setVisible(true);
+        guiWindow->setAlwaysOnTop(true);
+    });
+}
+
+void HelperPluginHost::hideGui()
+{
+    if (guiWindow)
+    {
+        juce::MessageManager::callAsync([this]()
+        {
+            guiWindow.reset();
+        });
+    }
+}
+
+// --- State ---
+
+juce::String HelperPluginHost::getStateBase64() const
+{
+    if (!plugin) return {};
+
+    juce::MemoryBlock stateData;
+    plugin->getStateInformation(stateData);
+    return stateData.toBase64Encoding();
+}
+
+bool HelperPluginHost::setStateBase64(const juce::String& base64State)
+{
+    if (!plugin) return false;
+
+    juce::MemoryBlock stateData;
+    if (!stateData.fromBase64Encoding(base64State))
+        return false;
+
+    plugin->setStateInformation(stateData.getData(), (int)stateData.getSize());
+    return true;
+}
+
+void HelperPluginHost::configure(double sampleRate, int blockSize, int channels)
+{
+    currentSampleRate = sampleRate;
+    currentBlockSize = blockSize;
+    currentChannels = channels;
+
+    if (plugin)
+    {
+        plugin->releaseResources();
+        plugin->prepareToPlay(sampleRate, blockSize);
+    }
+}