Upload Source/Plugin/PluginBridgeProcessor.cpp

Source/Plugin/PluginBridgeProcessor.cpp

@@ -1,6 +1,6 @@
 #include "PluginBridgeProcessor.h"
 #include "PluginBridgeEditor.h"
-#include "IPCProtocol.h"
+#include "McpServer.h"
 
 #include "json.hpp"
 using json = nlohmann::json;
@@ -8,24 +8,25 @@ using json = nlohmann::json;
 PluginBridgeProcessor::PluginBridgeProcessor()
     : AudioProcessor(BusesProperties()
                          .withInput("Input", juce::AudioChannelSet::stereo(), true)
-                         .withOutput("Output", juce::AudioChannelSet::stereo(), true)),
-      mcpServer(PluginBridgeConstants::kDefaultMcpPort, helper)
+                         .withOutput("Output", juce::AudioChannelSet::stereo(), true))
 {
-    helper.onHelperCrashed = [this]()
-    {
-        pluginLoaded = false;
-        pluginName.clear();
-        pluginParamCount = 0;
-        DBG("PluginBridgeProcessor: Helper crashed — plugin unloaded");
-    };
-
-    mcpServer.start();
+    // Register plugin formats
+    #if JUCE_PLUGINHOST_VST3
+    formatManager.addFormat(new juce::VST3PluginFormat());
+    #endif
+    #if JUCE_PLUGINHOST_AU
+    formatManager.addFormat(new juce::AudioUnitPluginFormat());
+    #endif
+
+    // Start MCP server
+    mcpServer = std::make_unique<McpServer>(PluginBridgeConstants::kDefaultMcpPort, *this);
+    mcpServer->start();
 }
 
 PluginBridgeProcessor::~PluginBridgeProcessor()
 {
-    mcpServer.stop();
-    helper.killHelper();
+    mcpServer->stop();
+    unloadPlugin();
 }
 
 void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
@@ -33,29 +34,22 @@ void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock
     currentSampleRate = sampleRate;
     currentBlockSize = samplesPerBlock;
 
-    if (helper.isHelperRunning())
+    juce::ScopedLock sl(pluginLock);
+    if (hostedPlugin)
     {
-        json cmd = {{"cmd", "configure"},
-                    {"sampleRate", sampleRate},
-                    {"blockSize", samplesPerBlock},
-                    {"channels", 2}};
-        helper.sendCommand(cmd.dump());
-
-        auto* header = helper.getSharedAudio().getHeader();
-        if (header)
-        {
-            header->sampleRate.store((uint32_t)sampleRate);
-            header->blockSize.store((uint32_t)samplesPerBlock);
-            header->numChannels.store(2);
-        }
+        hostedPlugin->setRateAndBufferSizeDetails(sampleRate, samplesPerBlock);
+        hostedPlugin->prepareToPlay(sampleRate, samplesPerBlock);
     }
 }
 
 void PluginBridgeProcessor::releaseResources()
 {
+    juce::ScopedLock sl(pluginLock);
+    if (hostedPlugin)
+        hostedPlugin->releaseResources();
 }
 
-void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer&)
+void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midi)
 {
     juce::ScopedNoDenormals noDenormals;
 
@@ -64,163 +58,217 @@ void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce:
     for (auto i = totalNumInputChannels; i < totalNumOutputChannels; ++i)
         buffer.clear(i, 0, buffer.getNumSamples());
 
-    if (!pluginLoaded || !helper.isHelperRunning())
+    juce::ScopedLock sl(pluginLock);
+    if (hostedPlugin)
+        hostedPlugin->processBlock(buffer, midi);
+}
+
+juce::AudioProcessorEditor* PluginBridgeProcessor::createEditor()
+{
+    return new PluginBridgeEditor(*this);
+}
+
+// --- Plugin Loading (IN-PROCESS) ---
+
+void PluginBridgeProcessor::loadPlugin(const juce::String& path)
+{
+    unloadPlugin();
+
+    // Check blocklist
+    if (blocklist.isBlocked(path))
+    {
+        if (onLoadFailed)
+            onLoadFailed("Plugin is blocklisted (crashed previously)");
         return;
+    }
 
-    auto& shm = helper.getSharedAudio();
-    if (!shm.isValid()) return;
+    juce::File pluginFile(path);
+    if (!pluginFile.exists())
+    {
+        if (onLoadFailed)
+            onLoadFailed("Plugin file not found");
+        return;
+    }
 
-    int numChannels = buffer.getNumChannels();
-    int numSamples = buffer.getNumSamples();
+    // Find plugin description
+    juce::OwnedArray<juce::PluginDescription> typesFound;
 
-    const float* inputPtrs[2] = {
-        buffer.getReadPointer(0),
-        numChannels > 1 ? buffer.getReadPointer(1) : buffer.getReadPointer(0)
-    };
-    shm.writeInput(inputPtrs, numChannels, numSamples);
+    for (int i = 0; i < formatManager.getNumFormats(); ++i)
+    {
+        auto* format = formatManager.getFormat(i);
+        bool isVST3 = pluginFile.getFileExtension() == ".vst3";
+        bool isAU = pluginFile.getFileExtension() == ".component";
 
-    auto* header = shm.getHeader();
-    header->blockSize.store((uint32_t)numSamples);
-    header->numChannels.store((uint32_t)numChannels);
-    header->state.store(kStateInputReady);
+        if (isVST3 && format->getName() != "VST3") continue;
+        if (isAU && format->getName() != "AudioUnit") continue;
 
-    helper.getInputSem().signal();
+        format->findAllTypesForFile(typesFound, pluginFile.getFullPathName());
+        if (typesFound.size() > 0)
+            break;
+    }
 
-    if (helper.getOutputSem().wait(IPC::kProcessBlockTimeoutMs))
+    if (typesFound.isEmpty())
     {
-        float* outputPtrs[2] = {
-            buffer.getWritePointer(0),
-            numChannels > 1 ? buffer.getWritePointer(1) : buffer.getWritePointer(0)
-        };
-        shm.readOutput(outputPtrs, numChannels, numSamples);
-        header->state.store(kStateIdle);
+        if (onLoadFailed)
+            onLoadFailed("Plugin format not recognized");
+        return;
     }
-}
 
-juce::AudioProcessorEditor* PluginBridgeProcessor::createEditor()
-{
-    return new PluginBridgeEditor(*this);
-}
+    // Create plugin instance
+    juce::String errorMessage;
+    auto instance = formatManager.createPluginInstance(
+        *typesFound[0], currentSampleRate, currentBlockSize, errorMessage);
 
-void PluginBridgeProcessor::getStateInformation(juce::MemoryBlock& destData)
-{
-    juce::ValueTree state("PluginBridgeState");
-    state.setProperty("pluginPath", pluginPath, nullptr);
+    if (instance == nullptr)
+    {
+        DBG("PluginBridgeProcessor: Failed to load: " + errorMessage);
+        // Add to blocklist if it fails
+        blocklist.addBlocked(path);
+        if (onLoadFailed)
+            onLoadFailed("Failed to load: " + errorMessage);
+        return;
+    }
+
+    // Configure the plugin
+    instance->enableAllBuses();
 
-    if (pluginLoaded && helper.isHelperRunning())
+    auto layout = juce::AudioProcessor::BusesLayout();
+    layout.inputBuses.add(juce::AudioChannelSet::stereo());
+    layout.outputBuses.add(juce::AudioChannelSet::stereo());
+
+    if (instance->checkBusesLayoutSupported(layout))
+        instance->setBusesLayout(layout);
+
+    instance->setRateAndBufferSizeDetails(currentSampleRate, currentBlockSize);
+    instance->prepareToPlay(currentSampleRate, currentBlockSize);
+
+    // Swap in
     {
-        auto response = helper.sendCommand("{\"cmd\":\"get_state\"}");
-        try {
-            auto j = json::parse(response);
-            if (j.value("ok", false))
-                state.setProperty("pluginState", juce::String(j["state"].get<std::string>()), nullptr);
-        } catch (...) {}
+        juce::ScopedLock sl(pluginLock);
+        hostedPlugin = std::move(instance);
     }
 
-    juce::MemoryOutputStream stream(destData, false);
-    state.writeToStream(stream);
+    pluginPath = path;
+    DBG("PluginBridgeProcessor: Loaded " + getLoadedPluginName() +
+        " (" + juce::String(getLoadedPluginParamCount()) + " params)");
+
+    if (onPluginLoaded)
+        onPluginLoaded();
 }
 
-void PluginBridgeProcessor::setStateInformation(const void* data, int sizeInBytes)
+void PluginBridgeProcessor::unloadPlugin()
 {
-    auto state = juce::ValueTree::readFromData(data, (size_t)sizeInBytes);
-    if (state.isValid())
     {
-        auto path = state.getProperty("pluginPath").toString();
-        if (path.isNotEmpty())
+        juce::ScopedLock sl(pluginLock);
+        if (hostedPlugin)
         {
-            loadPlugin(path);
-
-            auto pluginState = state.getProperty("pluginState").toString();
-            if (pluginState.isNotEmpty() && helper.isHelperRunning())
-            {
-                json cmd = {{"cmd", "set_state"}, {"state", pluginState.toStdString()}};
-                helper.sendCommand(cmd.dump());
-            }
+            hostedPlugin->releaseResources();
+            hostedPlugin.reset();
         }
     }
+
+    pluginPath.clear();
+
+    if (onPluginUnloaded)
+        onPluginUnloaded();
 }
 
-bool PluginBridgeProcessor::isMcpServerRunning() const
+juce::String PluginBridgeProcessor::getLoadedPluginName() const
 {
-    return mcpServer.isRunning();
+    juce::ScopedLock sl(pluginLock);
+    return hostedPlugin ? hostedPlugin->getName() : juce::String();
 }
 
-int PluginBridgeProcessor::getMcpServerPort() const
+int PluginBridgeProcessor::getLoadedPluginParamCount() const
 {
-    return mcpServer.getPort();
+    juce::ScopedLock sl(pluginLock);
+    return hostedPlugin ? hostedPlugin->getParameters().size() : 0;
 }
 
-void PluginBridgeProcessor::loadPlugin(const juce::String& path)
+// --- Parameters ---
+
+std::vector<PluginBridgeProcessor::ParamInfo> PluginBridgeProcessor::searchParams(const juce::String& keyword) const
 {
-    if (!helper.isHelperRunning())
+    std::vector<ParamInfo> results;
+    juce::ScopedLock sl(pluginLock);
+    if (!hostedPlugin) return results;
+
+    auto& params = hostedPlugin->getParameters();
+    auto keywordLower = keyword.toLowerCase();
+
+    for (int i = 0; i < params.size(); ++i)
     {
-        if (!helper.spawnHelper())
+        auto* param = params[i];
+        auto name = param->getName(128);
+
+        if (keyword.isEmpty() || name.toLowerCase().contains(keywordLower))
         {
-            DBG("PluginBridgeProcessor: Failed to spawn helper");
-            return;
+            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;
         }
-
-        json configCmd = {{"cmd", "configure"},
-                          {"sampleRate", currentSampleRate},
-                          {"blockSize", currentBlockSize},
-                          {"channels", 2}};
-        helper.sendCommand(configCmd.dump());
     }
 
-    json loadCmd = {{"cmd", "load"},
-                    {"path", path.toStdString()},
-                    {"sampleRate", currentSampleRate},
-                    {"blockSize", currentBlockSize}};
+    return results;
+}
 
-    auto response = helper.sendCommand(loadCmd.dump());
+std::vector<std::pair<int, float>> PluginBridgeProcessor::getParams(const std::vector<int>& ids) const
+{
+    std::vector<std::pair<int, float>> results;
+    juce::ScopedLock sl(pluginLock);
+    if (!hostedPlugin) return results;
 
-    try
+    auto& params = hostedPlugin->getParameters();
+    for (int idx : ids)
     {
-        auto j = json::parse(response);
-        if (j.value("ok", false))
-        {
-            pluginLoaded = true;
-            pluginName = juce::String(j["name"].get<std::string>());
-            pluginParamCount = j.value("params", 0);
-            pluginPath = path;
-            DBG("PluginBridgeProcessor: Loaded " + pluginName + " (" + juce::String(pluginParamCount) + " params)");
-        }
-        else
-        {
-            pluginLoaded = false;
-            DBG("PluginBridgeProcessor: Failed to load: " + juce::String(j.value("error", "unknown")));
-        }
-    }
-    catch (...)
-    {
-        pluginLoaded = false;
+        if (idx >= 0 && idx < params.size())
+            results.push_back({idx, params[idx]->getValue()});
     }
+    return results;
 }
 
-void PluginBridgeProcessor::unloadPlugin()
+bool PluginBridgeProcessor::setParams(const std::map<int, float>& values)
 {
-    if (helper.isHelperRunning())
-        helper.sendCommand("{\"cmd\":\"unload\"}");
+    juce::ScopedLock sl(pluginLock);
+    if (!hostedPlugin) return false;
 
-    pluginLoaded = false;
-    pluginName.clear();
-    pluginPath.clear();
-    pluginParamCount = 0;
+    auto& params = hostedPlugin->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;
 }
 
-void PluginBridgeProcessor::showPluginGui()
-{
-    if (helper.isHelperRunning())
-        helper.sendCommand("{\"cmd\":\"show_gui\"}");
-}
+// --- Hosted Plugin Editor ---
 
-void PluginBridgeProcessor::hidePluginGui()
+juce::AudioProcessorEditor* PluginBridgeProcessor::createHostedPluginEditor()
 {
-    if (helper.isHelperRunning())
-        helper.sendCommand("{\"cmd\":\"hide_gui\"}");
+    juce::ScopedLock sl(pluginLock);
+    if (hostedPlugin && hostedPlugin->hasEditor())
+        return hostedPlugin->createEditor();
+    return nullptr;
 }
 
+// --- Plugin List ---
+
 juce::Array<juce::File> PluginBridgeProcessor::getInstalledPluginFiles() const
 {
     juce::Array<juce::File> results;
@@ -249,6 +297,82 @@ juce::Array<juce::File> PluginBridgeProcessor::getInstalledPluginFiles() const
     return results;
 }
 
+// --- Blocklist ---
+
+bool PluginBridgeProcessor::isBlocked(const juce::String& path) const
+{
+    return blocklist.isBlocked(path);
+}
+
+// --- State ---
+
+void PluginBridgeProcessor::getStateInformation(juce::MemoryBlock& destData)
+{
+    juce::ValueTree state("PluginBridgeState");
+    state.setProperty("pluginPath", pluginPath, nullptr);
+
+    juce::ScopedLock sl(pluginLock);
+    if (hostedPlugin)
+    {
+        juce::MemoryBlock pluginState;
+        hostedPlugin->getStateInformation(pluginState);
+        state.setProperty("pluginState", pluginState.toBase64Encoding(), nullptr);
+    }
+
+    juce::MemoryOutputStream stream(destData, false);
+    state.writeToStream(stream);
+}
+
+void PluginBridgeProcessor::setStateInformation(const void* data, int sizeInBytes)
+{
+    auto state = juce::ValueTree::readFromData(data, (size_t)sizeInBytes);
+    if (state.isValid())
+    {
+        auto path = state.getProperty("pluginPath").toString();
+        if (path.isNotEmpty())
+        {
+            loadPlugin(path);
+
+            auto pluginStateB64 = state.getProperty("pluginState").toString();
+            if (pluginStateB64.isNotEmpty())
+            {
+                juce::MemoryBlock pluginState;
+                if (pluginState.fromBase64Encoding(pluginStateB64))
+                {
+                    juce::ScopedLock sl(pluginLock);
+                    if (hostedPlugin)
+                        hostedPlugin->setStateInformation(pluginState.getData(), (int)pluginState.getSize());
+                }
+            }
+        }
+    }
+}
+
+// --- MCP ---
+
+bool PluginBridgeProcessor::isMcpServerRunning() const
+{
+    return mcpServer && mcpServer->isRunning();
+}
+
+int PluginBridgeProcessor::getMcpServerPort() const
+{
+    return mcpServer ? mcpServer->getPort() : 0;
+}
+
+// --- Test Safety (Helper-based) ---
+
+PluginBridgeProcessor::TestResult PluginBridgeProcessor::testPluginSafety(const juce::String& path)
+{
+    // TODO: Spawn helper to test-load plugin
+    // For now, all plugins are treated as safe unless blocklisted
+    if (blocklist.isBlocked(path))
+        return TestResult::Unsafe;
+    return TestResult::Safe;
+}
+
+// --- Entry Point ---
+
 juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
 {
     return new PluginBridgeProcessor();