pluginbridge / Source /Plugin /PluginBridgeProcessor.cpp
RAM2118's picture
Sprint 5: route audio through in-process plugin for SAFE plugins
2eb08b2 verified
Raw History Blame
27.9 kB
#include "PluginBridgeProcessor.h"
#include "PluginBridgeEditor.h"
#include "IPCProtocol.h"
#include "PBLog.h"
#include <sys/wait.h>
#include <spawn.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <chrono>
extern char** environ;
#include "json.hpp"
using json = nlohmann::json;
PluginBridgeProcessor::PluginBridgeProcessor()
: AudioProcessor(BusesProperties()
.withInput("Input", juce::AudioChannelSet::stereo(), true)
.withOutput("Output", juce::AudioChannelSet::stereo(), true)),
mcpServer(std::make_unique<McpServer>(PluginBridgeConstants::kDefaultMcpPort, helper))
{
PBLog::startSession("Processor");
PBLOG("Processor", "Constructor β€” PluginBridgeProcessor created");
inProcessFormatManager.addFormat(new juce::VST3PluginFormat());
inProcessFormatManager.addFormat(new juce::AudioUnitPluginFormat());
helper.onHelperCrashed = [this]()
{
PBLOG("Processor", "⚠️ Helper crashed β€” clearing plugin state");
if (pluginPath.isNotEmpty())
{
PBLOG("Processor", "⚠️ Marking \"" + pluginName + "\" as UNSAFE (Helper crash)");
safetyDB.setSafety(pluginPath, PluginSafetyDB::Safety::Unsafe);
}
pluginLoaded = false;
pluginName.clear();
pluginParamCount = 0;
unloadInProcessPlugin();
DBG("PluginBridgeProcessor: Helper crashed");
};
helper.onParamChanged = [this](int idx, float val)
{
if (!inProcessPlugin) return;
auto& params = inProcessPlugin->getParameters();
if (idx < 0 || idx >= params.size()) return;
suppressParamSync.store(true);
juce::MessageManager::callAsync([this, idx, val]()
{
if (!inProcessPlugin) return;
auto& p = inProcessPlugin->getParameters();
if (idx < p.size())
p[idx]->setValueNotifyingHost(juce::jlimit(0.0f, 1.0f, val));
suppressParamSync.store(false);
});
};
mcpServer->getAnalysisCallback = [this]() { return analyser.getCompactAnalysis(); };
mcpServer->start();
startBackgroundScan();
}
PluginBridgeProcessor::~PluginBridgeProcessor()
{
PBLOG("Processor", "Destructor β€” tearing down");
stopBackgroundScan();
mcpServer->stop();
unloadInProcessPlugin();
helper.killHelper();
PBLOG("Processor", "Destructor β€” done");
}
void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
{
currentSampleRate = sampleRate;
currentBlockSize = samplesPerBlock;
analyser.prepareToPlay(sampleRate, samplesPerBlock);
// If in-process plugin is already loaded, update its sample rate/block size too
if (inProcessPlugin)
{
inProcessPlugin->releaseResources();
inProcessPlugin->prepareToPlay(sampleRate, samplesPerBlock);
}
if (helper.isHelperRunning())
{
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);
}
}
}
void PluginBridgeProcessor::releaseResources() {}
void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages)
{
juce::ScopedNoDenormals noDenormals;
for (auto i = getTotalNumInputChannels(); i < getTotalNumOutputChannels(); ++i)
buffer.clear(i, 0, buffer.getNumSamples());
if (!pluginLoaded) return;
// ── SAFE plugin path: audio goes through in-process instance ──────────────
if (inProcessPlugin != nullptr)
{
inProcessPlugin->processBlock(buffer, midiMessages);
analyser.processBlock(buffer);
return;
}
// ── UNSAFE plugin path: audio goes through Helper via shared memory ───────
if (!helper.isHelperRunning()) return;
auto& shm = helper.getSharedAudio();
if (!shm.isValid()) return;
int numChannels = buffer.getNumChannels();
int numSamples = buffer.getNumSamples();
const float* inputPtrs[2] = {
buffer.getReadPointer(0),
numChannels > 1 ? buffer.getReadPointer(1) : buffer.getReadPointer(0)
};
shm.writeInput(inputPtrs, numChannels, numSamples);
auto* header = shm.getHeader();
header->blockSize.store((uint32_t)numSamples);
header->numChannels.store((uint32_t)numChannels);
header->state.store(kStateInputReady);
helper.getInputSem().signal();
if (helper.getOutputSem().wait(IPC::kProcessBlockTimeoutMs))
{
float* outputPtrs[2] = {
buffer.getWritePointer(0),
numChannels > 1 ? buffer.getWritePointer(1) : buffer.getWritePointer(0)
};
shm.readOutput(outputPtrs, numChannels, numSamples);
header->state.store(kStateIdle);
analyser.processBlock(buffer);
}
}
juce::AudioProcessorEditor* PluginBridgeProcessor::createEditor()
{
return new PluginBridgeEditor(*this);
}
// ── In-process plugin (now handles BOTH audio + GUI for SAFE plugins) ─────────
void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
{
PBLOG("Processor", "loadInProcessPlugin: " + juce::File(path).getFileName());
unloadInProcessPlugin();
juce::File pluginFile(path);
if (!pluginFile.exists())
{
PBLOG("Processor", "loadInProcessPlugin: file not found β€” abort");
return;
}
juce::OwnedArray<juce::PluginDescription> typesFound;
for (int i = 0; i < inProcessFormatManager.getNumFormats(); ++i)
{
auto* format = inProcessFormatManager.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())
{
PBLOG("Processor", "loadInProcessPlugin: no types found");
return;
}
PBLOG("Processor", "loadInProcessPlugin: creating instance \"" + typesFound[0]->name + "\"");
juce::String err;
inProcessPlugin = inProcessFormatManager.createPluginInstance(
*typesFound[0], currentSampleRate, currentBlockSize, err);
if (!inProcessPlugin)
{
PBLOG("Processor", "loadInProcessPlugin: createPluginInstance FAILED β€” " + err);
DBG("PluginBridgeProcessor: in-process load failed: " + err);
return;
}
// Configure buses
inProcessPlugin->enableAllBuses();
auto layout = juce::AudioProcessor::BusesLayout();
layout.inputBuses.add(juce::AudioChannelSet::stereo());
layout.outputBuses.add(juce::AudioChannelSet::stereo());
if (inProcessPlugin->checkBusesLayoutSupported(layout))
inProcessPlugin->setBusesLayout(layout);
// Prepare for audio processing β€” safe for SAFE plugins (unsafe ones never reach here)
if (currentSampleRate > 0 && currentBlockSize > 0)
inProcessPlugin->prepareToPlay(currentSampleRate, currentBlockSize);
// Sync state from Helper (if it has state loaded already)
auto response = helper.sendCommand("{\"cmd\":\"get_state\"}");
try {
auto j = json::parse(response);
if (j.value("ok", false))
{
auto stateB64 = juce::String(j["state"].get<std::string>());
if (stateB64.isNotEmpty())
{
juce::MemoryBlock stateData;
if (stateData.fromBase64Encoding(stateB64))
inProcessPlugin->setStateInformation(stateData.getData(), (int)stateData.getSize());
}
}
} catch (...) {}
inProcessPlugin->addListener(this);
PBLOG("Processor", "loadInProcessPlugin: SUCCESS β€” \"" + inProcessPlugin->getName() + "\" (audio+GUI)");
DBG("PluginBridgeProcessor: in-process plugin loaded: " + inProcessPlugin->getName());
}
void PluginBridgeProcessor::unloadInProcessPlugin()
{
if (inProcessPlugin)
{
PBLOG("Processor", "unloadInProcessPlugin: removing \"" + inProcessPlugin->getName() + "\"");
inProcessPlugin->removeListener(this);
inProcessPlugin->releaseResources();
inProcessPlugin.reset();
PBLOG("Processor", "unloadInProcessPlugin: done");
}
else
{
PBLOG("Processor", "unloadInProcessPlugin: nothing to unload");
}
}
void PluginBridgeProcessor::audioProcessorParameterChanged(juce::AudioProcessor*, int paramIdx, float value)
{
if (suppressParamSync.load()) return;
if (!helper.isHelperRunning()) return;
auto cmdStr = json({{"cmd","set_params"},{"values",{{std::to_string(paramIdx), value}}}}).dump();
std::thread([this, cmdStr]() { helper.sendCommand(cmdStr); }).detach();
}
// ── Plugin Loading ────────────────────────────────────────────────────────────
void PluginBridgeProcessor::loadPlugin(const juce::String& path)
{
PBLOG("Processor", "loadPlugin: " + juce::File(path).getFileName()
+ " (currently loaded: " + (pluginLoaded ? pluginName : "none") + ")");
if (blocklist.isBlocked(path))
{
PBLOG("Processor", "loadPlugin: BLOCKED β€” skipping");
if (onLoadFailed) onLoadFailed("Not compatible (crashed previously)");
return;
}
auto safety = safetyDB.getSafety(path);
PBLOG("Processor", juce::String("loadPlugin: safety = ")
+ (safety == PluginSafetyDB::Safety::Safe ? "SAFE"
: safety == PluginSafetyDB::Safety::Unsafe ? "UNSAFE"
: "UNKNOWN"));
if (safety == PluginSafetyDB::Safety::Unknown)
{
if (onLoadFailed) onLoadFailed("Scanning plugin...");
std::thread([this, path]()
{
bool safe = runPluginScan(path);
safetyDB.setSafety(path, safe ? PluginSafetyDB::Safety::Safe
: PluginSafetyDB::Safety::Unsafe);
juce::MessageManager::callAsync([this, path]() { loadPlugin(path); });
}).detach();
return;
}
if (onPluginWillLoad)
{
PBLOG("Processor", "loadPlugin: firing onPluginWillLoad β†’ editor will detach old GUI");
onPluginWillLoad();
}
if (!helper.isHelperRunning())
{
PBLOG("Processor", "loadPlugin: Helper not running β€” spawning");
if (!helper.spawnHelper())
{
PBLOG("Processor", "loadPlugin: ❌ spawnHelper FAILED");
if (onLoadFailed) onLoadFailed("Failed to start helper process");
return;
}
PBLOG("Processor", "loadPlugin: Helper spawned OK");
json configCmd = {{"cmd","configure"},{"sampleRate",currentSampleRate},
{"blockSize",currentBlockSize},{"channels",2}};
helper.sendCommand(configCmd.dump());
}
PBLOG("Processor", "loadPlugin: sending load cmd to Helper...");
json loadCmd = {{"cmd","load"},{"path",path.toStdString()},
{"sampleRate",currentSampleRate},{"blockSize",currentBlockSize}};
auto response = helper.sendCommand(loadCmd.dump());
PBLOG("Processor", "loadPlugin: Helper response: " + juce::String(response));
try
{
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;
PBLOG("Processor", "loadPlugin: Helper loaded \"" + pluginName
+ "\" (" + juce::String(pluginParamCount) + " params)");
if (safety == PluginSafetyDB::Safety::Safe)
{
juce::MessageManager::callAsync([this, path]()
{
PBLOG("Processor", "loadPlugin: [msg thread] calling loadInProcessPlugin");
loadInProcessPlugin(path);
PBLOG("Processor", "loadPlugin: [msg thread] firing onPluginLoaded");
if (onPluginLoaded) onPluginLoaded();
});
}
else
{
PBLOG("Processor", "loadPlugin: UNSAFE β€” skipping in-process load, audio-only mode");
juce::MessageManager::callAsync([this]()
{
if (onPluginLoaded) onPluginLoaded();
});
}
}
else
{
PBLOG("Processor", "loadPlugin: ❌ Helper refused load: "
+ juce::String(j.value("error", "unknown")));
pluginLoaded = false;
pluginPath.clear();
blocklist.addBlocked(path);
if (onLoadFailed)
onLoadFailed("Not compatible: " + juce::String(j.value("error", "unknown")));
}
}
catch (...)
{
PBLOG("Processor", "loadPlugin: ❌ exception parsing Helper response");
pluginLoaded = false;
pluginPath.clear();
blocklist.addBlocked(path);
if (onLoadFailed) onLoadFailed("Helper communication error");
}
}
void PluginBridgeProcessor::unloadPlugin()
{
PBLOG("Processor", "unloadPlugin: \"" + pluginName + "\"");
if (helper.isHelperRunning())
helper.sendCommand("{\"cmd\":\"unload\"}");
pluginLoaded = false;
pluginName.clear();
pluginPath.clear();
pluginParamCount = 0;
unloadInProcessPlugin();
PBLOG("Processor", "unloadPlugin: done");
if (onPluginUnloaded)
juce::MessageManager::callAsync([this]() { if (onPluginUnloaded) onPluginUnloaded(); });
}
// ── Plugin Scanner ────────────────────────────────────────────────────────────
static juce::String signalName(int sig)
{
switch (sig)
{
case SIGSEGV: return "SIGSEGV (segmentation fault)";
case SIGABRT: return "SIGABRT (abort)";
case SIGBUS: return "SIGBUS (bus error)";
case SIGILL: return "SIGILL (illegal instruction)";
case SIGFPE: return "SIGFPE (floating point exception)";
case SIGKILL: return "SIGKILL (killed β€” timeout)";
default: return "signal " + juce::String(sig);
}
}
static void writeScanLog(const juce::String& pluginPath, bool safe,
const juce::String& reason, const juce::String& captured)
{
auto logFile = juce::File::getSpecialLocation(juce::File::userApplicationDataDirectory)
.getChildFile("PluginBridge").getChildFile("scan.log");
logFile.getParentDirectory().createDirectory();
auto ts = juce::Time::getCurrentTime().formatted("%Y-%m-%d %H:%M:%S");
auto name = juce::File(pluginPath).getFileName();
juce::String entry;
entry << "────────────────────────────────────────\n"
<< ts << " " << name << "\n"
<< "Path : " << pluginPath << "\n"
<< "Result : " << (safe ? "SAFE βœ“" : "UNSAFE βœ—") << "\n";
if (!reason.isEmpty()) entry << "Reason : " << reason << "\n";
if (captured.isNotEmpty())
{
entry << "Scanner output:\n";
for (auto& line : juce::StringArray::fromLines(captured))
if (line.isNotEmpty()) entry << " " << line << "\n";
}
entry << "\n";
logFile.appendText(entry);
}
bool PluginBridgeProcessor::runPluginScan(const juce::String& path)
{
auto helperApp = juce::File::getSpecialLocation(juce::File::currentExecutableFile)
.getParentDirectory().getParentDirectory()
.getChildFile("Resources").getChildFile("PluginBridgeHelper.app")
.getChildFile("Contents").getChildFile("MacOS")
.getChildFile(PluginBridgeConstants::kHelperBinaryName);
if (!helperApp.exists())
{
helperApp = juce::File::getSpecialLocation(juce::File::currentExecutableFile)
.getParentDirectory().getParentDirectory()
.getChildFile("Resources")
.getChildFile(PluginBridgeConstants::kHelperBinaryName);
}
if (!helperApp.exists())
{
writeScanLog(path, false, "Helper binary not found", {});
return false;
}
int pipeFd[2];
if (pipe(pipeFd) != 0) { writeScanLog(path, false, "pipe() failed", {}); return false; }
fcntl(pipeFd[0], F_SETFL, O_NONBLOCK);
auto helperPathStr = helperApp.getFullPathName().toStdString();
auto pluginPathStr = path.toStdString();
posix_spawn_file_actions_t actions;
posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_adddup2(&actions, pipeFd[1], STDERR_FILENO);
posix_spawn_file_actions_addclose(&actions, pipeFd[0]);
pid_t pid;
char* argv[] = { (char*)helperPathStr.c_str(), (char*)"--scan",
(char*)pluginPathStr.c_str(), nullptr };
int spawnResult = posix_spawn(&pid, helperPathStr.c_str(), &actions, nullptr, argv, environ);
posix_spawn_file_actions_destroy(&actions);
close(pipeFd[1]);
if (spawnResult != 0)
{
close(pipeFd[0]);
writeScanLog(path, false, "posix_spawn failed: " + juce::String(strerror(spawnResult)), {});
return false;
}
bool timedOut = true;
int finalStatus = 0;
auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(10);
while (std::chrono::steady_clock::now() < deadline)
{
pid_t result = waitpid(pid, &finalStatus, WNOHANG);
if (result == pid) { timedOut = false; break; }
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
if (timedOut) { kill(pid, SIGKILL); waitpid(pid, &finalStatus, 0); }
juce::String captured;
{ char buf[8192]; ssize_t n;
while ((n = read(pipeFd[0], buf, sizeof(buf)-1)) > 0) { buf[n]='\0'; captured += buf; } }
close(pipeFd[0]);
bool safe = false;
juce::String reason;
if (timedOut) reason = "Timed out after 10s";
else if (WIFEXITED(finalStatus)) { int code = WEXITSTATUS(finalStatus); safe = (code==0);
reason = safe ? "" : "Exited with code " + juce::String(code); }
else if (WIFSIGNALED(finalStatus)) reason = "Crashed: " + signalName(WTERMSIG(finalStatus));
writeScanLog(path, safe, reason, captured);
return safe;
}
// ── Background Scanner ────────────────────────────────────────────────────────
void PluginBridgeProcessor::startBackgroundScan()
{
if (scanRunning.load()) return;
scanRunning.store(true);
scanThread = std::thread([this]()
{
auto files = getInstalledPluginFiles();
for (int i = 0; i < files.size() && scanRunning.load(); ++i)
{
auto path = files[i].getFullPathName();
if (safetyDB.getSafety(path) != PluginSafetyDB::Safety::Unknown) continue;
while (helper.isHelperRunning() && scanRunning.load())
std::this_thread::sleep_for(std::chrono::milliseconds(500));
if (!scanRunning.load()) break;
bool safe = runPluginScan(path);
safetyDB.setSafety(path, safe ? PluginSafetyDB::Safety::Safe
: PluginSafetyDB::Safety::Unsafe);
if (onScanProgress)
juce::MessageManager::callAsync([this, path, safe]()
{ if (onScanProgress) onScanProgress(path, safe); });
}
scanRunning.store(false);
});
}
void PluginBridgeProcessor::stopBackgroundScan()
{
scanRunning.store(false);
if (scanThread.joinable()) scanThread.join();
}
// ── Plugin List ───────────────────────────────────────────────────────────────
juce::Array<juce::File> PluginBridgeProcessor::getInstalledPluginFiles() const
{
juce::Array<juce::File> results;
std::set<std::string> seen;
struct DirSpec { juce::File dir; const char* pattern; };
std::vector<DirSpec> specs = {
{ juce::File("/Library/Audio/Plug-Ins/VST3"), "*.vst3" },
{ juce::File::getSpecialLocation(juce::File::userHomeDirectory)
.getChildFile("Library/Audio/Plug-Ins/VST3"), "*.vst3" },
{ juce::File("/Library/Audio/Plug-Ins/Components"), "*.component" },
{ juce::File::getSpecialLocation(juce::File::userHomeDirectory)
.getChildFile("Library/Audio/Plug-Ins/Components"), "*.component" }
};
for (auto& spec : specs)
{
if (!spec.dir.isDirectory()) continue;
auto files = spec.dir.findChildFiles(juce::File::findDirectories, false, spec.pattern);
for (auto& f : files)
{
auto stem = f.getFileNameWithoutExtension().toStdString();
if (seen.insert(stem).second) results.add(f);
}
}
results.sort();
return results;
}
bool PluginBridgeProcessor::isBlocked(const juce::String& path) const { return blocklist.isBlocked(path); }
// ── Manufacturer name ─────────────────────────────────────────────────────────
static juce::String cleanManufacturer(const juce::String& raw)
{
auto s = raw.trim();
if (s.isEmpty()) return {};
if (s.containsOnly("0123456789.")) return {};
auto lower = s.toLowerCase();
if (lower.startsWith("copyright"))
{
auto rest = s.substring(9).trim();
if (rest.startsWithIgnoreCase("(c)")) rest = rest.substring(3).trim();
else if (rest.startsWith(juce::String::fromUTF8("\xc2\xa9")))
rest = rest.substring(juce::String::fromUTF8("\xc2\xa9").length()).trim();
else if (rest.startsWith(juce::CharPointer_UTF8("\xc2\xa9")))
rest = rest.substring(1).trim();
auto spacePos = rest.indexOfChar(' ');
if (spacePos > 0) rest = rest.substring(spacePos + 1).trim();
if (rest.isNotEmpty()) return rest;
return {};
}
return s;
}
static juce::String plistValue(const juce::String& text, const juce::String& key)
{
auto pos = text.fromFirstOccurrenceOf(key, false, true);
if (pos.isEmpty()) return {};
return pos.fromFirstOccurrenceOf("<string>", false, false)
.upToFirstOccurrenceOf("</string>", false, false).trim();
}
juce::String PluginBridgeProcessor::getPluginManufacturer(const juce::File& f) const
{
auto pathKey = f.getFullPathName().toStdString();
{ std::lock_guard<std::mutex> lock(manufacturerCacheMutex);
auto it = manufacturerCache.find(pathKey);
if (it != manufacturerCache.end()) return juce::String(it->second); }
juce::String mfr;
if (f.getFileExtension().toLowerCase() == ".vst3")
{
auto infoPlist = f.getChildFile("Contents").getChildFile("Info.plist");
if (infoPlist.existsAsFile())
{
auto text = infoPlist.loadFileAsString();
auto copyright = plistValue(text, "NSHumanReadableCopyright");
mfr = cleanManufacturer(copyright);
if (mfr.isEmpty())
{
auto infoStr = plistValue(text, "CFBundleGetInfoString");
if (infoStr.contains(","))
{
auto beforeComma = infoStr.upToFirstOccurrenceOf(",", false, false).trim();
auto first = beforeComma.upToFirstOccurrenceOf(" ", false, false).trim();
if (first.isNotEmpty() && !first.containsOnly("0123456789.")) mfr = first;
}
if (mfr.isEmpty()) mfr = cleanManufacturer(infoStr);
}
if (mfr.isEmpty())
{
auto bid = plistValue(text, "CFBundleIdentifier");
auto segs = juce::StringArray::fromTokens(bid, ".", "");
if (segs.size() >= 2)
{
auto slug = segs[1].trim();
if (slug.isNotEmpty() && slug != "apple" && slug != "com")
{ slug = slug.substring(0,1).toUpperCase() + slug.substring(1); mfr = slug; }
}
}
}
if (mfr.isEmpty())
{
auto moduleInfo = f.getChildFile("Contents").getChildFile("moduleinfo.json");
if (moduleInfo.existsAsFile())
{
try { auto j = json::parse(moduleInfo.loadFileAsString().toStdString());
auto vendor = cleanManufacturer(juce::String(j.value("vendor","")));
if (vendor.isNotEmpty()) mfr = vendor; } catch (...) {}
}
}
}
if (mfr.isEmpty())
{
auto name = f.getFileNameWithoutExtension();
auto first = name.upToFirstOccurrenceOf(" ", false, false);
if (first.isNotEmpty() && !first.containsOnly("0123456789.")) mfr = first;
else mfr = name;
}
if (mfr.isEmpty()) mfr = "Other";
std::lock_guard<std::mutex> lock(manufacturerCacheMutex);
manufacturerCache[pathKey] = mfr.toStdString();
return mfr;
}
// ── State ─────────────────────────────────────────────────────────────────────
void PluginBridgeProcessor::getStateInformation(juce::MemoryBlock& destData)
{
juce::ValueTree state("PluginBridgeState");
state.setProperty("pluginPath", pluginPath, nullptr);
if (pluginLoaded && helper.isHelperRunning())
{
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::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()) return;
auto path = state.getProperty("pluginPath").toString();
if (path.isEmpty()) return;
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());
}
}
// ── MCP ───────────────────────────────────────────────────────────────────────
bool PluginBridgeProcessor::isMcpServerRunning() const { return mcpServer && mcpServer->isRunning(); }
int PluginBridgeProcessor::getMcpServerPort() const { return mcpServer ? mcpServer->getPort() : 0; }
juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
return new PluginBridgeProcessor();
}