Download Source/Plugin/PluginBridgeProcessor.cpp from RAM2118/pluginbridge: direct link, hf CLI and curl.
- Browser
- Download file 24.8 kB
-
https://huggingface.co/RAM2118/pluginbridge/resolve/6f6ce59cd6bcf346e1cb1f75788b9a26ecf478c3/Source/Plugin/PluginBridgeProcessor.cpp
- Command line
-
hf download hf://RAM2118/pluginbridge@6f6ce59cd6bcf346e1cb1f75788b9a26ecf478c3/Source/Plugin/PluginBridgeProcessor.cpp
-
curl -L -o PluginBridgeProcessor.cpp https://huggingface.co/RAM2118/pluginbridge/resolve/6f6ce59cd6bcf346e1cb1f75788b9a26ecf478c3/Source/Plugin/PluginBridgeProcessor.cpp
24.8 kB
| extern char** environ; | |
| 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>(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(); | |
| }; | |
| 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); | |
| }); | |
| }; | |
| // Wire callbacks for MCP tools | |
| mcpServer->getAnalysisCallback = [this]() { return analyser.getCompactAnalysis(); }; | |
| mcpServer->channelNameCallback = [this]() { return channelName.toStdString(); }; | |
| mcpServer->start(); | |
| // Register this instance in the shared registry | |
| InstanceRegistry::registerInstance(channelName.toStdString(), mcpServer->getPort()); | |
| PBLOG("Processor", "MCP server on port " + juce::String(mcpServer->getPort()) | |
| + " β channel: " + channelName); | |
| startBackgroundScan(); | |
| } | |
| PluginBridgeProcessor::~PluginBridgeProcessor() | |
| { | |
| PBLOG("Processor", "Destructor β tearing down"); | |
| stopBackgroundScan(); | |
| // Unregister from shared registry | |
| InstanceRegistry::unregisterInstance(channelName.toStdString()); | |
| mcpServer->stop(); | |
| unloadInProcessPlugin(); | |
| helper.killHelper(); | |
| PBLOG("Processor", "Destructor β done"); | |
| } | |
| // ββ Channel Name ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| void PluginBridgeProcessor::setChannelName(const juce::String& name) | |
| { | |
| if (name == channelName) return; | |
| // Unregister old name, update, register new | |
| InstanceRegistry::unregisterInstance(channelName.toStdString()); | |
| channelName = name; | |
| InstanceRegistry::registerInstance(channelName.toStdString(), mcpServer->getPort()); | |
| PBLOG("Processor", "Channel renamed to: " + channelName); | |
| } | |
| // ββ Audio βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock) | |
| { | |
| currentSampleRate = sampleRate; | |
| currentBlockSize = samplesPerBlock; | |
| analyser.prepareToPlay(sampleRate, samplesPerBlock); | |
| 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; | |
| if (inProcessPlugin != nullptr) | |
| { | |
| inProcessPlugin->processBlock(buffer, midiMessages); | |
| analyser.processBlock(buffer); | |
| return; | |
| } | |
| 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 βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| 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"); 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; } | |
| juce::String err; | |
| inProcessPlugin = inProcessFormatManager.createPluginInstance( | |
| *typesFound[0], currentSampleRate, currentBlockSize, err); | |
| if (!inProcessPlugin) { PBLOG("Processor", "loadInProcessPlugin: FAILED β " + err); return; } | |
| 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); | |
| if (currentSampleRate > 0 && currentBlockSize > 0) | |
| inProcessPlugin->prepareToPlay(currentSampleRate, currentBlockSize); | |
| 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() + "\""); | |
| } | |
| void PluginBridgeProcessor::unloadInProcessPlugin() | |
| { | |
| if (inProcessPlugin) | |
| { | |
| PBLOG("Processor", "unloadInProcessPlugin: " + inProcessPlugin->getName()); | |
| inProcessPlugin->removeListener(this); | |
| inProcessPlugin->releaseResources(); | |
| inProcessPlugin.reset(); | |
| } | |
| } | |
| 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()); | |
| if (blocklist.isBlocked(path)) | |
| { | |
| if (onLoadFailed) onLoadFailed("Not compatible (crashed previously)"); | |
| return; | |
| } | |
| auto safety = safetyDB.getSafety(path); | |
| PBLOG("Processor", "loadPlugin: safety = " + juce::String( | |
| 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) onPluginWillLoad(); | |
| if (!helper.isHelperRunning()) | |
| { | |
| if (!helper.spawnHelper()) | |
| { | |
| if (onLoadFailed) onLoadFailed("Failed to start helper process"); | |
| return; | |
| } | |
| 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}}; | |
| auto response = helper.sendCommand(loadCmd.dump()); | |
| 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: loaded \"" + pluginName + "\""); | |
| if (safety == PluginSafetyDB::Safety::Safe) | |
| { | |
| juce::MessageManager::callAsync([this, path]() | |
| { | |
| loadInProcessPlugin(path); | |
| if (onPluginLoaded) onPluginLoaded(); | |
| }); | |
| } | |
| else | |
| { | |
| juce::MessageManager::callAsync([this]() | |
| { if (onPluginLoaded) onPluginLoaded(); }); | |
| } | |
| } | |
| else | |
| { | |
| pluginLoaded = false; | |
| pluginPath.clear(); | |
| blocklist.addBlocked(path); | |
| if (onLoadFailed) onLoadFailed("Not compatible: " + juce::String(j.value("error","unknown"))); | |
| } | |
| } | |
| catch (...) | |
| { | |
| 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(); | |
| if (onPluginUnloaded) | |
| juce::MessageManager::callAsync([this]() { if (onPluginUnloaded) onPluginUnloaded(); }); | |
| } | |
| // ββ Scanner βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| static juce::String signalName(int sig) | |
| { | |
| switch (sig) { | |
| case SIGSEGV: return "SIGSEGV"; case SIGABRT: return "SIGABRT"; | |
| case SIGBUS: return "SIGBUS"; case SIGILL: return "SIGILL"; | |
| case SIGFPE: return "SIGFPE"; case SIGKILL: return "SIGKILL"; | |
| 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"); | |
| juce::String entry; | |
| entry << "βββ\n" << ts << " " << juce::File(pluginPath).getFileName() | |
| << "\nResult: " << (safe ? "SAFE" : "UNSAFE"); | |
| if (!reason.isEmpty()) entry << " (" << reason << ")"; | |
| if (captured.isNotEmpty()) entry << "\nOutput: " << captured.substring(0, 500); | |
| entry << "\n\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 not found", {}); return false; } | |
| int pipeFd[2]; | |
| if (pipe(pipeFd) != 0) return false; | |
| fcntl(pipeFd[0], F_SETFL, O_NONBLOCK); | |
| auto hStr = helperApp.getFullPathName().toStdString(); | |
| auto pStr = 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*)hStr.c_str(), (char*)"--scan", (char*)pStr.c_str(), nullptr }; | |
| int sr = posix_spawn(&pid, hStr.c_str(), &actions, nullptr, argv, environ); | |
| posix_spawn_file_actions_destroy(&actions); | |
| close(pipeFd[1]); | |
| if (sr != 0) { close(pipeFd[0]); return false; } | |
| bool timedOut = true; int status = 0; | |
| auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(10); | |
| while (std::chrono::steady_clock::now() < deadline) { | |
| if (waitpid(pid, &status, WNOHANG) == pid) { timedOut = false; break; } | |
| std::this_thread::sleep_for(std::chrono::milliseconds(100)); | |
| } | |
| if (timedOut) { kill(pid, SIGKILL); waitpid(pid, &status, 0); } | |
| juce::String captured; | |
| { char buf[4096]; ssize_t n; | |
| while ((n = read(pipeFd[0], buf, sizeof(buf)-1)) > 0) { buf[n]=0; captured += buf; } } | |
| close(pipeFd[0]); | |
| bool safe = !timedOut && WIFEXITED(status) && WEXITSTATUS(status) == 0; | |
| juce::String reason = timedOut ? "Timeout" : | |
| WIFSIGNALED(status) ? signalName(WTERMSIG(status)) : | |
| (!safe ? "Exit " + juce::String(WEXITSTATUS(status)) : ""); | |
| writeScanLog(path, safe, reason, captured); | |
| return safe; | |
| } | |
| 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 D { juce::File dir; const char* pat; }; | |
| std::vector<D> 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& s : specs) { | |
| if (!s.dir.isDirectory()) continue; | |
| for (auto& f : s.dir.findChildFiles(juce::File::findDirectories, false, s.pat)) | |
| if (seen.insert(f.getFileNameWithoutExtension().toStdString()).second) results.add(f); | |
| } | |
| results.sort(); | |
| return results; | |
| } | |
| bool PluginBridgeProcessor::isBlocked(const juce::String& path) const { return blocklist.isBlocked(path); } | |
| // ββ Manufacturer ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| static juce::String cleanManufacturer(const juce::String& raw) { | |
| auto s = raw.trim(); if (s.isEmpty() || s.containsOnly("0123456789.")) return {}; | |
| if (s.toLowerCase().startsWith("copyright")) { | |
| auto r = s.substring(9).trim(); | |
| if (r.startsWithIgnoreCase("(c)")) r = r.substring(3).trim(); | |
| else if (r.startsWith(juce::String::fromUTF8("\xc2\xa9"))) | |
| r = r.substring(juce::String::fromUTF8("\xc2\xa9").length()).trim(); | |
| auto sp = r.indexOfChar(' '); if (sp > 0) r = r.substring(sp+1).trim(); | |
| return r.isNotEmpty() ? r : juce::String(); | |
| } | |
| return s; | |
| } | |
| static juce::String plistValue(const juce::String& t, const juce::String& k) { | |
| auto p = t.fromFirstOccurrenceOf(k, false, true); if (p.isEmpty()) return {}; | |
| return p.fromFirstOccurrenceOf("<string>", false, false) | |
| .upToFirstOccurrenceOf("</string>", false, false).trim(); | |
| } | |
| juce::String PluginBridgeProcessor::getPluginManufacturer(const juce::File& f) const { | |
| auto pk = f.getFullPathName().toStdString(); | |
| { std::lock_guard<std::mutex> l(manufacturerCacheMutex); | |
| auto it = manufacturerCache.find(pk); if (it != manufacturerCache.end()) return juce::String(it->second); } | |
| juce::String mfr; | |
| if (f.getFileExtension().toLowerCase() == ".vst3") { | |
| auto ip = f.getChildFile("Contents").getChildFile("Info.plist"); | |
| if (ip.existsAsFile()) { | |
| auto t = ip.loadFileAsString(); | |
| mfr = cleanManufacturer(plistValue(t, "NSHumanReadableCopyright")); | |
| if (mfr.isEmpty()) { auto is = plistValue(t, "CFBundleGetInfoString"); | |
| if (is.contains(",")) { auto bc = is.upToFirstOccurrenceOf(",",false,false).trim(); | |
| auto fw = bc.upToFirstOccurrenceOf(" ",false,false).trim(); | |
| if (fw.isNotEmpty() && !fw.containsOnly("0123456789.")) mfr = fw; } | |
| if (mfr.isEmpty()) mfr = cleanManufacturer(is); } | |
| if (mfr.isEmpty()) { auto bid = plistValue(t, "CFBundleIdentifier"); | |
| auto segs = juce::StringArray::fromTokens(bid,".","" ); | |
| if (segs.size()>=2) { auto sl = segs[1].trim(); | |
| if (sl.isNotEmpty()&&sl!="apple"&&sl!="com") | |
| mfr = sl.substring(0,1).toUpperCase()+sl.substring(1); } } | |
| } | |
| if (mfr.isEmpty()) { auto mi = f.getChildFile("Contents").getChildFile("moduleinfo.json"); | |
| if (mi.existsAsFile()) { try { auto j = json::parse(mi.loadFileAsString().toStdString()); | |
| mfr = cleanManufacturer(juce::String(j.value("vendor",""))); } catch(...){} } } | |
| } | |
| if (mfr.isEmpty()) { auto n = f.getFileNameWithoutExtension(); | |
| auto fw = n.upToFirstOccurrenceOf(" ",false,false); | |
| mfr = (fw.isNotEmpty()&&!fw.containsOnly("0123456789.")) ? fw : n; } | |
| if (mfr.isEmpty()) mfr = "Other"; | |
| std::lock_guard<std::mutex> l(manufacturerCacheMutex); manufacturerCache[pk] = mfr.toStdString(); return mfr; | |
| } | |
| // ββ State βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| void PluginBridgeProcessor::getStateInformation(juce::MemoryBlock& destData) | |
| { | |
| juce::ValueTree state("PluginBridgeState"); | |
| state.setProperty("pluginPath", pluginPath, nullptr); | |
| state.setProperty("channelName", channelName, nullptr); | |
| if (pluginLoaded && helper.isHelperRunning()) { | |
| auto r = helper.sendCommand("{\"cmd\":\"get_state\"}"); | |
| try { auto j = json::parse(r); 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; | |
| // Restore channel name | |
| auto savedChannel = state.getProperty("channelName", "Unnamed").toString(); | |
| setChannelName(savedChannel); | |
| 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(); } | |