Upload Source/Helper/main.cpp

Source/Helper/main.cpp

@@ -1,78 +1,99 @@
 #include <juce_audio_processors/juce_audio_processors.h>
+#include <juce_audio_utils/juce_audio_utils.h>
 #include <juce_gui_basics/juce_gui_basics.h>
 #include <juce_events/juce_events.h>
 
+#include "SharedAudioBuffer.h"
+#include "IPCProtocol.h"
+#include "Constants.h"
 #include "HelperPluginHost.h"
+#include "HelperIPC.h"
 
-// PluginBridgeHelper — TEST MODE ONLY
-// Spawned by PluginBridge to test if a plugin can load safely.
-// If the plugin crashes, only this process dies. Ableton survives.
-//
-// Usage: PluginBridgeHelper --test "/path/to/plugin.vst3"
-// Exit code 0 = safe, exit code 1 = failed to load, crash = unsafe
-
-class HelperApplication : public juce::JUCEApplication, private juce::Timer
+class HelperApplication : public juce::JUCEApplication
 {
 public:
     const juce::String getApplicationName() override { return "PluginBridgeHelper"; }
-    const juce::String getApplicationVersion() override { return "0.3.0"; }
+    const juce::String getApplicationVersion() override { return PluginBridgeConstants::kVersion; }
 
     void initialise(const juce::String& commandLine) override
     {
-        // Parse --test flag. Everything after --test is the path (may contain spaces).
-        auto testFlagPos = commandLine.indexOf("--test");
-        if (testFlagPos < 0)
+        auto args = juce::StringArray::fromTokens(commandLine, " ", "\"");
+
+        int parentPid = 0;
+        for (int i = 0; i < args.size() - 1; ++i)
         {
-            DBG("HelperApplication: Usage: --test \"/path/to/plugin.vst3\"");
-            setApplicationReturnValue(1);
-            quit();
-            return;
+            if (args[i] == "--pid")
+                parentPid = args[i + 1].getIntValue();
         }
 
-        // Extract path: skip "--test " (7 chars), trim quotes
-        pluginPath = commandLine.substring(testFlagPos + 7).trim().unquoted();
-
-        if (pluginPath.isEmpty())
+        if (parentPid == 0)
         {
-            DBG("HelperApplication: No plugin path provided");
-            setApplicationReturnValue(1);
+            DBG("HelperApplication: --pid argument required");
             quit();
             return;
         }
 
-        DBG("HelperApplication: Testing plugin: " + pluginPath);
+        DBG("HelperApplication: Starting for parent PID " + juce::String(parentPid));
 
-        // Start test on a timer so the message loop is running
-        // (some plugins need it for VST3 validation)
-        startTimer(100);
-    }
+        // Set the layer port name based on parent PID
+        auto portName = juce::String(IPC::getLayerPortName(parentPid));
 
-    void timerCallback() override
-    {
-        stopTimer();
+        pluginHost = std::make_unique<HelperPluginHost>();
+        pluginHost->layerPortName = portName;
 
-        HelperPluginHost host;
-        bool success = host.testLoad(pluginPath);
+        ipcServer = std::make_unique<HelperIPC>(parentPid, *pluginHost);
 
-        if (success)
+        auto shmName = IPC::getShmName(parentPid);
+        if (!sharedAudio.open(shmName))
         {
-            DBG("HelperApplication: Plugin loaded successfully — SAFE");
-            setApplicationReturnValue(0);
+            DBG("HelperApplication: Failed to open shared memory: " + shmName);
+            quit();
+            return;
         }
-        else
+
+        if (!inputSem.open(IPC::getInputSemName(parentPid)) ||
+            !outputSem.open(IPC::getOutputSemName(parentPid)))
         {
-            DBG("HelperApplication: Plugin failed to load — UNSAFE");
-            setApplicationReturnValue(1);
+            DBG("HelperApplication: Failed to open semaphores");
+            quit();
+            return;
         }
 
-        quit();
+        if (!ipcServer->connect())
+        {
+            DBG("HelperApplication: Failed to connect to parent IPC socket");
+            quit();
+            return;
+        }
+
+        pluginHost->setSharedAudio(&sharedAudio, &inputSem, &outputSem);
+        pluginHost->startProcessing();
+        ipcServer->sendReady();
+
+        DBG("HelperApplication: Ready and running");
     }
 
-    void shutdown() override {}
-    void systemRequestedQuit() override { quit(); }
+    void shutdown() override
+    {
+        if (pluginHost)
+            pluginHost->stopProcessing();
+
+        ipcServer.reset();
+        pluginHost.reset();
+        sharedAudio.destroy();
+    }
+
+    void systemRequestedQuit() override
+    {
+        quit();
+    }
 
 private:
-    juce::String pluginPath;
+    std::unique_ptr<HelperPluginHost> pluginHost;
+    std::unique_ptr<HelperIPC> ipcServer;
+    SharedAudioBuffer sharedAudio;
+    SharedSemaphore inputSem;
+    SharedSemaphore outputSem;
 };
 
 START_JUCE_APPLICATION(HelperApplication)