{

#if JUCE_IOS

if (ProjectInfo::isStandalone) {

return BusesProperties().withOutput("Output", AudioChannelSet::stereo(), true).withInput("Input", AudioChannelSet::mono(), true);

}

// If you intend to build AUv3 on macOS, you'll also need these

if (ProjectInfo::isFx) {

return BusesProperties().withOutput("Output", AudioChannelSet::stereo(), true).withInput("Input", AudioChannelSet::stereo(), true);

} else {

return BusesProperties().withOutput("Output", AudioChannelSet::stereo(), true);

}

#else

AudioProcessor::BusesProperties busesProperties;

if (ProjectInfo::isStandalone) {

busesProperties.addBus(true, "Main Input", AudioChannelSet::stereo(), true);

busesProperties.addBus(false, "Main Output", AudioChannelSet::stereo(), true);

} else {

busesProperties.addBus(true, "Main Input", AudioChannelSet::stereo(), true);

for (int i = 1; i < numInputBuses; i++)

busesProperties.addBus(true, "Aux Input " + String(i), AudioChannelSet::stereo(), false);

busesProperties.addBus(false, "Main Output", AudioChannelSet::stereo(), true);

for (int i = 1; i < numOutputBuses; i++)

busesProperties.addBus(false, "Aux Output" + String(i), AudioChannelSet::stereo(), false);

}

return busesProperties;

#endif

: AudioProcessor(buildBusesProperties())

, internalSynth(std::make_unique<InternalSynth>())

, hostInfoUpdater(this)

{

#if PERFETTO

MelatoninPerfetto::get().beginSession();

#endif

// Make sure to use dots for decimal numbers, pd requires that

std::setlocale(LC_NUMERIC, "C");

{

MessageManagerLock const mmLock; // Do we need this? Isn't this already on the messageManager?

LookAndFeel::setDefaultLookAndFeel(&lnf.get());

// Initialise directory structure and settings file, do this only once if we're inside the DAW

static bool filesystemInitialised = false;

if(!filesystemInitialised) {

auto succeeded = initialiseFilesystem();

if(!succeeded)

{

logError("Failed to initialise filesystem. Is the disk full?");

}

filesystemInitialised = true;

}

settingsFile = SettingsFile::getInstance()->initialise();

}

statusbarSource = std::make_unique<StatusbarSource>();

auto* volumeParameter = new PlugDataParameter(this, "volume", 0.8f, true, 0, 0.0f, 1.0f);

addParameter(volumeParameter);

volume = volumeParameter->getValuePointer();

// XML tree for storing additional data in DAW session

extraData = std::make_unique<XmlElement>("ExtraData");

// General purpose automation parameters you can get by using "receive param1" etc.

for (int n = 0; n < numParameters; n++) {

auto* parameter = new PlugDataParameter(this, "param" + String(n + 1), 0.0f, false, n + 1, 0.0f, 1.0f);

addParameter(parameter);

}

// Make sure that the parameter valuetree has a name, to prevent assertion failures

// parameters.replaceState(ValueTree("plugdata"));

logMessage("plugdata v" + String(ProjectInfo::versionString));

auto const gitHash = String(PLUGDATA_GIT_HASH);

if (gitHash.isNotEmpty()) {

logMessage("Nightly build: " + gitHash);

}

logMessage("Based on " + String(pd_version).upToFirstOccurrenceOf("(", false, false));

logMessage("Libraries:");

logMessage(else_version);

logMessage(cyclone_version);

#if ENABLE_GEM

logMessage(gem_version);

#endif

logMessage(heavylib_version);

// Set up midi buffers

midiBufferInternalSynth.ensureSize(2048);

atoms_playhead.reserve(3);

atoms_playhead.resize(1);

autosave = std::make_unique<Autosave>(this);

auto themeName = settingsFile->getProperty<String>("theme");

// Make sure theme exists

if (!settingsFile->getTheme(themeName).isValid()) {

settingsFile->setProperty("theme", PlugDataLook::selectedThemes[0]);

themeName = PlugDataLook::selectedThemes[0];

}

setTheme(themeName, true);

settingsFile->saveSettings();

oversampling = std::clamp(settingsFile->getProperty<int>("oversampling"), 0, 3);

setEnableLimiter(settingsFile->getProperty<int>("protected"));

setLimiterThreshold(settingsFile->getProperty<int>("limiter_threshold"));

if(ProjectInfo::isStandalone) {

midiDeviceManager.setInternalSynthPort(settingsFile->getProperty<int>("internal_synth"));

}

else {

midiDeviceManager.setInternalSynthPort(0);

}

auto currentThemeTree = settingsFile->getCurrentTheme();

// ag: This needs to be done *after* the library data has been unpacked on

// first launch.

initialisePd(pdlua_version);

logMessage(pdlua_version);

updateSearchPaths();

objectLibrary = std::make_unique<pd::Library>(this);

setLatencySamples(pd::Instance::getBlockSize());

settingsFile->startChangeListener();

sendMessagesFromQueue();

startDSP();

{

setThis();

messageDispatcher->dequeueMessages();

{

setThis();

lockAudioThread();

messageDispatcher->dequeueMessages();

messageDispatcher->dequeueMessages();

unlockAudioThread();

{

if (!sourceDir.exists() || !targetDir.exists()) {

return;

}

// Cache frequently used values

const bool hasValidLastInitTime = lastInitTime.toMilliseconds() > 0;

const String deleteFlag = deleteIfNotExists ? "true" : "false";

// Get all source files once and build a lookup map for efficiency

auto sourceFiles = sourceDir.findChildFiles(juce::File::TypesOfFileToFind::findFiles, true);

std::unordered_set<String> sourceFileSet;

sourceFileSet.reserve(sourceFiles.size());

// Phase 1: Copy files from source to target (update newer files)

for (const auto& sourceFile : sourceFiles) {

const auto relativePath = sourceFile.getRelativePathFrom(sourceDir);

sourceFileSet.insert(relativePath.toStdString());

const auto targetFile = targetDir.getChildFile(relativePath);

// Create directory structure if needed

const auto parentDir = targetFile.getParentDirectory();

if (!parentDir.exists()) {

parentDir.createDirectory();

}

// Copy if target doesn't exist or source is newer

if (!targetFile.exists()) {

sourceFile.copyFileTo(targetFile);

} else {

const auto sourceModTime = sourceFile.getLastModificationTime();

const auto targetModTime = targetFile.getLastModificationTime();

if (sourceModTime > targetModTime) {

sourceFile.copyFileTo(targetFile);

}

}

}

// Phase 2: Delete files in target that don't exist in source (only if deleteIfNotExists is true)

if (deleteIfNotExists) {

auto targetFiles = targetDir.findChildFiles(juce::File::TypesOfFileToFind::findFiles, true);

// Pre-cache directory modification times to prevent updates during deletion

HashMap<String, Time> directoryModTimes;

std::unordered_set<String> uniqueDirPaths;

for (const auto& targetFile : targetFiles) {

const auto parentPath = targetFile.getParentDirectory().getFullPathName();

if (uniqueDirPaths.find(parentPath.toStdString()) == uniqueDirPaths.end()) {

uniqueDirPaths.insert(parentPath.toStdString());

directoryModTimes.set(parentPath, targetFile.getParentDirectory().getLastModificationTime());

}

}

SmallArray<File> directoriesToCleanup;

std::unordered_set<String> cleanupDirPaths; // Prevent duplicates

for (const auto& targetFile : targetFiles) {

const auto relativePath = targetFile.getRelativePathFrom(targetDir);

// Check if file exists in source using our pre-built set

if (sourceFileSet.find(relativePath.toStdString()) == sourceFileSet.end()) {

// File doesn't exist in source - candidate for deletion

bool shouldDelete = true;

if (hasValidLastInitTime) {

const auto parentPath = targetFile.getParentDirectory().getFullPathName();

const auto dirModTime = directoryModTimes[parentPath];

const auto fileModTime = targetFile.getLastModificationTime();

// Don't delete if either the directory OR the file was modified after last init

// This handles both renamed files (dir mod time) and copied files (file mod time)

if (dirModTime > lastInitTime || fileModTime > lastInitTime) {

shouldDelete = false;

}

}

if (shouldDelete) {

const auto parentDir = targetFile.getParentDirectory();

const auto parentPath = parentDir.getFullPathName();

targetFile.deleteFile();

// Add parent directory to cleanup list (avoid duplicates)

if (cleanupDirPaths.find(parentPath.toStdString()) == cleanupDirPaths.end()) {

cleanupDirPaths.insert(parentPath.toStdString());

directoriesToCleanup.add(parentDir);

}

}

}

}

// Clean up empty directories (process from deepest to shallowest)

for (const auto& parentDir : directoriesToCleanup) {

auto currentDir = parentDir;

while (currentDir != targetDir) {

// Check if directory is empty (ignoring hidden files)

const auto filesInDir = currentDir.findChildFiles(juce::File::TypesOfFileToFind::findFiles, false);

bool isEmpty = true;

for (const auto& file : filesInDir) {

if (!file.isHidden()) {

isEmpty = false;

break;

}

}

if (isEmpty) {

const auto parentRelativePath = currentDir.getRelativePathFrom(targetDir);

if (!sourceDir.getChildFile(parentRelativePath).exists()) {

const auto nextParent = currentDir.getParentDirectory();

currentDir.deleteRecursively();

currentDir = nextParent;

} else {

break; // Directory exists in source, keep it

}

} else {

break; // Directory is not empty, stop

}

}

}

}

{

auto const& homeDir = ProjectInfo::appDataDir;

auto const& versionDataDir = ProjectInfo::versionDataDir;

auto const dekenDir = homeDir.getChildFile("Externals");

auto const patchesDir = homeDir.getChildFile("Patches");

FileSystemWatcher::addGlobalIgnorePath(homeDir.getChildFile("Toolchain"));

#if JUCE_IOS

// TODO: remove this later. This is for iOS version transition

auto oldDir = File::getSpecialLocation(File::SpecialLocationType::userDocumentsDirectory).getChildFile("plugdata");

if (oldDir.isDirectory() && oldDir.getChildFile("Abstractions").isDirectory()) {

oldDir.deleteRecursively();

}

#elif !JUCE_WINDOWS

if (!homeDir.exists())

homeDir.createDirectory();

#endif

auto const initMutex = homeDir.getChildFile(".initialising");

// If this is true, another instance of plugdata is already initialising

// We wait a maximum of 5 seconds before we continue initialising, to prevent problems

int wait = 0;

while (initMutex.exists() && wait < 20) {

Time::waitForMillisecondCounter(Time::getMillisecondCounter() + 500);

wait++;

}

initMutex.create();

bool extractionCompleted = true;

// Check if the abstractions directory exists, if not, unzip it from binaryData

if (!versionDataDir.exists()) {

extractionCompleted = false;

// Binary data shouldn't be too big, then the compiler will run out of memory

// To prevent this, we split the binarydata into multiple files, and add them back together here

HeapArray<uint8_t> allData;

int i = 0;

while (true) {

int size;

auto* resource = BinaryData::getNamedResource((String("Filesystem_") + String(i)).toRawUTF8(), size);

if (!resource) {

break;

}

allData.insert(allData.end(), resource, resource + size);

i++;

}

versionDataDir.getParentDirectory().createDirectory();

int constexpr maxRetries = 3;

int retryCount = 0;

while(!extractionCompleted && retryCount < maxRetries) {

auto const tempVersionDataDir = versionDataDir.getParentDirectory().getChildFile("plugdata_version");

tempVersionDataDir.deleteRecursively();

if (!versionDataDir.getParentDirectory().createDirectory()) {

retryCount++;

continue;

}

if (!Decompress::extractTarXz(allData.data(), allData.size(), tempVersionDataDir.getParentDirectory(), 40 * 1024 * 1024)) {

retryCount++;

continue;

}

extractionCompleted = tempVersionDataDir.moveFileTo(versionDataDir);

if (!extractionCompleted) {

retryCount++;

Thread::sleep(100);

}

}

}

if (!dekenDir.exists()) {

dekenDir.createDirectory();

}

#if !JUCE_IOS

if (!patchesDir.exists()) {

patchesDir.createDirectory();

}

#endif

auto const testTonePatch = homeDir.getChildFile("testtone.pd");

auto const cpuTestPatch = homeDir.getChildFile("load-meter.pd");

if (testTonePatch.exists())

testTonePatch.deleteFile();

if (cpuTestPatch.exists())

cpuTestPatch.deleteFile();

File(versionDataDir.getChildFile("./Documentation/7.stuff/tools/testtone.pd")).copyFileTo(testTonePatch);

File(versionDataDir.getChildFile("./Documentation/7.stuff/tools/load-meter.pd")).copyFileTo(cpuTestPatch);

auto createLinkWithRetry = [&extractionCompleted](const File& linkPath, const File& targetPath, int const maxRetries = 3) {

for (int retry = 0; retry < maxRetries; retry++) {

#if JUCE_WINDOWS

// Clean up existing link/directory

if (linkPath.exists()) {

linkPath.deleteRecursively();

}

if(OSUtils::createJunction(linkPath.getFullPathName().replaceCharacters("/", "\\").toStdString(), targetPath.getFullPathName().toStdString())) return;

#else

if (linkPath.exists()) {

linkPath.deleteRecursively();

}

if(targetPath.createSymbolicLink(linkPath, true)) return;

#endif

if (retry < maxRetries - 1) {

Thread::sleep(100);

}

}

extractionCompleted = false;

};

// We always want to update the symlinks in case an older version of plugdata was used

#if JUCE_WINDOWS

// Get paths that need symlinks

auto abstractionsPath = versionDataDir.getChildFile("Abstractions").getFullPathName().replaceCharacters("/", "\\");

auto documentationPath = versionDataDir.getChildFile("Documentation").getFullPathName().replaceCharacters("/", "\\");

auto extraPath = versionDataDir.getChildFile("Extra").getFullPathName().replaceCharacters("/", "\\");

createLinkWithRetry(homeDir.getChildFile("Abstractions"), versionDataDir.getChildFile("Abstractions"));

createLinkWithRetry(homeDir.getChildFile("Documentation"), versionDataDir.getChildFile("Documentation"));

createLinkWithRetry(homeDir.getChildFile("Extra"), versionDataDir.getChildFile("Extra"));

// TODO: version transition code, remove this later

auto oldlocation = File::getSpecialLocation(File::SpecialLocationType::userDocumentsDirectory).getChildFile("plugdata");

auto backupLocation = File::getSpecialLocation(File::SpecialLocationType::userDocumentsDirectory).getChildFile("plugdata.old");

if (oldlocation.isDirectory() && !backupLocation.isDirectory()) {

// don't bother copying this, it's huge!

if (oldlocation.getChildFile("Toolchain").isDirectory())

oldlocation.getChildFile("Toolchain").deleteRecursively();

oldlocation.copyDirectoryTo(backupLocation);

oldlocation.deleteRecursively();

}

auto shortcut = File::getSpecialLocation(File::SpecialLocationType::userDocumentsDirectory).getChildFile("plugdata.LNK");

ProjectInfo::appDataDir.createShortcut("plugdata", shortcut);

#elif JUCE_IOS

createLinkWithRetry(homeDir.getChildFile("Abstractions"), versionDataDir.getChildFile("Abstractions"));

createLinkWithRetry(homeDir.getChildFile("Documentation"), versionDataDir.getChildFile("Documentation"));

createLinkWithRetry(homeDir.getChildFile("Extra"), versionDataDir.getChildFile("Extra"));

auto docsPatchesDir = File::getSpecialLocation(File::SpecialLocationType::userDocumentsDirectory).getChildFile("Patches");

if(patchesDir.isSymbolicLink())

{

patchesDir.deleteRecursively();

}

if(docsPatchesDir.isSymbolicLink())

{

docsPatchesDir.deleteRecursively();

}

patchesDir.createDirectory();

docsPatchesDir.createDirectory();

// On iOS, only the standalone can actually access the "patches" folder through the file manager. So we have to do this copying step to make sure it gets synced with our shared "Patches" folder

// Thanks to Reinissance for figuring out the copying logic!

if (ProjectInfo::isStandalone) {

// Read last standalone initialization time

auto timestampFile = homeDir.getChildFile(".standalone_last_init");

Time lastInitTime;

if (timestampFile.existsAsFile()) {

auto timestampString = timestampFile.loadFileAsString().trim();

if (timestampString.isNotEmpty()) {

lastInitTime = Time(timestampString.getLargeIntValue());

}

}

else {

// If the file doesn't exist, we assume this is the first run

lastInitTime = Time::getCurrentTime();

// Create the file to store the current time

timestampFile.create();

}

// Sync files both ways: documents -> shared and shared -> documents

// Pass the last init time to prevent deletion of files created by AUv3 apps after standalone was last initialized

syncDirectoryFiles(patchesDir, docsPatchesDir, lastInitTime, true); // Copy newer files from shared to documents and delete files that don't exist there in shared

syncDirectoryFiles(docsPatchesDir, patchesDir, lastInitTime); // Copy newer files from documents to shared

// Store current time as the last initialization time for next run...

auto currentTime = Time::getCurrentTime();

timestampFile.replaceWithText(String(currentTime.toMilliseconds()));

}

#else

createLinkWithRetry(homeDir.getChildFile("Abstractions"), versionDataDir.getChildFile("Abstractions"));

createLinkWithRetry(homeDir.getChildFile("Documentation"), versionDataDir.getChildFile("Documentation"));

createLinkWithRetry(homeDir.getChildFile("Extra"), versionDataDir.getChildFile("Extra"));

#endif

initMutex.deleteFile();

return extractionCompleted;

{

// Reload pd search paths from settings

auto const pathTree = settingsFile->getPathsTree();

setThis();

lockAudioThread();

libpd_clear_search_path();

auto paths = SmallArray<File, 12>(pd::Library::defaultPaths.begin(), pd::Library::defaultPaths.end());

for (auto child : pathTree) {

auto path = child.getProperty("Path").toString().replace("\\", "/");

paths.add_unique(path);

}

for (auto const& path : paths) {

libpd_add_to_search_path(path.getFullPathName().toRawUTF8());

}

for (auto const& path : DekenInterface::getExternalPaths()) {

libpd_add_to_search_path(path.replace("\\", "/").toRawUTF8());

}

auto librariesTree = settingsFile->getLibrariesTree();

for (auto library : librariesTree) {

if (!library.hasProperty("Name") || library.getProperty("Name").toString().isEmpty()) {

librariesTree.removeChild(library, nullptr);

}

}

// Load startup libraries that the user defined in settings

for (auto library : librariesTree) {

auto const libName = library.getProperty("Name").toString();

// Load the library: this must be done after updating paths

// If the library is already loaded, it will return true

// This will load the libraries directly instead of on restart, not sure if Pd does that but it's actually nice

if (!loadLibrary(libName)) {

logError("Failed to load library: " + libName);

}

}

unlockAudioThread();

{

#if JUCE_IOS

return !ProjectInfo::isFx;

#endif

return true;

{

#if JUCE_IOS

return ProjectInfo::isStandalone;

#endif

return true;

{

if (isPositiveAndBelow(index, Presets::presets.size())) {

MemoryOutputStream data;

Base64::convertFromBase64(data, Presets::presets[index].second);

if (data.getDataSize() > 0) {

setStateInformation(data.getData(), static_cast<int>(data.getDataSize()));

lastSetProgram = index;

}

}

{

if (isPositiveAndBelow(index, Presets::presets.size())) {

return Presets::presets[index].first;

}

return "Init preset";

{

settingsFile->setProperty("oversampling", var(amount));

if (oversampling == amount)

return;

oversampling = amount;

auto const blockSize = AudioProcessor::getBlockSize();

auto const sampleRate = AudioProcessor::getSampleRate();

suspendProcessing(true);

prepareToPlay(sampleRate, blockSize);

suspendProcessing(false);

{

auto const threshold = StackArray<float, 4> { -12.f, -6.f, 0.f, 3.f }[amount];

limiter.setThreshold(threshold);

settingsFile->setProperty("limiter_threshold", var(amount));

{

auto const blockSize = AudioProcessor::getBlockSize();

auto const sampleRate = AudioProcessor::getSampleRate();

suspendProcessing(true);

prepareToPlay(sampleRate, blockSize);

suspendProcessing(false);

{

if (approximatelyEqual(sampleRate, 0.0))

return;

float const oversampleFactor = 1 << oversampling;

auto maxChannels = std::max(getTotalNumInputChannels(), getTotalNumOutputChannels());

prepareDSP(getTotalNumInputChannels(), getTotalNumOutputChannels(), sampleRate * oversampleFactor);

oversampler = std::make_unique<dsp::Oversampling<float>>(std::max(1, maxChannels), oversampling, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR, false);

oversampler->initProcessing(samplesPerBlock);

auto const internalSynthPort = midiDeviceManager.getInternalSynthPort();

if (internalSynthPort >= 0 && ProjectInfo::isStandalone) {

internalSynth->prepare(sampleRate, samplesPerBlock);

}

audioAdvancement = 0;

auto const pdBlockSize = static_cast<size_t>(Instance::getBlockSize());

audioBufferIn.setSize(maxChannels, pdBlockSize);

audioBufferOut.setSize(maxChannels, pdBlockSize);

audioVectorIn.resize(maxChannels * pdBlockSize, 0.0f);

audioVectorOut.resize(maxChannels * pdBlockSize, 0.0f);

// If the block size is a multiple of 64 and we are not a plugin, we can optimise the process loop

// Audio plugins can choose to send in a smaller block size when automation is happening

variableBlockSize = !ProjectInfo::isStandalone || samplesPerBlock < pdBlockSize || samplesPerBlock % pdBlockSize != 0;

if (variableBlockSize) {

inputFifo = std::make_unique<AudioMidiFifo>(maxChannels, std::max<int>(pdBlockSize, samplesPerBlock * oversampleFactor) * 3);

outputFifo = std::make_unique<AudioMidiFifo>(maxChannels, std::max<int>(pdBlockSize, samplesPerBlock * oversampleFactor) * 3);

outputFifo->writeSilence(Instance::getBlockSize());

}

midiByteIndex = 0;

midiByteBuffer[0] = 0;

midiByteBuffer[1] = 0;

midiByteBuffer[2] = 0;

midiBufferInternalSynth.ensureSize(2048);

midiDeviceManager.prepareToPlay(sampleRate * oversampleFactor);

cpuLoadMeasurer.reset(sampleRate, samplesPerBlock);

statusbarSource->setSampleRate(sampleRate);

statusbarSource->setBufferSize(samplesPerBlock);

statusbarSource->prepareToPlay(getTotalNumOutputChannels());

limiter.prepare({ sampleRate, static_cast<uint32>(samplesPerBlock), std::max(1u, static_cast<uint32>(maxChannels)) });

smoothedGain.reset(AudioProcessor::getSampleRate(), 0.02);

if(!ProjectInfo::isStandalone) {

backupRunLoopInterval = static_cast<int>(samplesPerBlock / sampleRate * 2000.0);

backupRunLoopInterval = jmax(24, backupRunLoopInterval);

backupRunLoop.startTimer(backupRunLoopInterval * 32);

}

{

#if JUCE_IOS

return (layouts.getMainOutputChannels() <= 2) && (layouts.getMainInputChannels() <= 2);

#endif

#if JucePlugin_IsMidiEffect

ignoreUnused(layouts);

return true;

#endif

int ninch = 0;

int noutch = 0;

for (int bus = 0; bus < layouts.outputBuses.size(); bus++) {

int const nchb = layouts.getNumChannels(false, bus);

if (layouts.outputBuses[bus].isDisabled())

continue;

if (nchb == 0)

return false;

noutch += nchb;

}

for (int bus = 0; bus < layouts.inputBuses.size(); bus++) {

int const nchb = layouts.getNumChannels(true, bus);

if (layouts.inputBuses[bus].isDisabled())

continue;

if (nchb == 0)

return false;

ninch += nchb;

}

return ninch <= 32 && noutch <= 32;

{

auto const newTheme = settingsFile->getProperty<String>("theme");

if (PlugDataLook::currentTheme != newTheme) {

setTheme(newTheme);

}

updateSearchPaths();

if (objectLibrary)

objectLibrary->updateLibrary();

{

bypassBuffer.makeCopyOf(buffer);

// It's better to keep sending blocks into Pd, so messaging can still work and there are no gaps in the users' audio stream

processBlock(bypassBuffer, midiBuffer);

for (int ch = 0; ch < getTotalNumOutputChannels(); ch++)

buffer.clear(ch, 0, buffer.getNumSamples());

{

isProcessingAudio = true;

ScopedNoDenormals noDenormals;

AudioProcessLoadMeasurer::ScopedTimer cpuTimer(cpuLoadMeasurer, buffer.getNumSamples());

auto const totalNumInputChannels = getTotalNumInputChannels();

auto const totalNumOutputChannels = getTotalNumOutputChannels();

auto midiInputHistory = midiBuffer;

setThis();

if(!ProjectInfo::isStandalone) {

backupLoopLock.enter();

backupRunLoop.stopTimer();

backupLoopLock.exit();

}

sendPlayhead();

for (int i = totalNumInputChannels; i < totalNumOutputChannels; ++i) {

buffer.clear(i, 0, buffer.getNumSamples());

}

auto targetBlock = dsp::AudioBlock<float>(buffer);

auto const blockOut = oversampling > 0 ? oversampler->processSamplesUp(targetBlock) : targetBlock;

if (variableBlockSize) {

processVariable(blockOut, midiBuffer);

} else {

midiBuffer.clear();

processConstant(blockOut);

}

if (oversampling > 0) {

oversampler->processSamplesDown(targetBlock);

}

auto const targetGain = volume->load();

float mappedTargetGain = 0.0f;

// Slider value 0.8 is default unity

// The top part of the slider 0.8 - 1.0 is mapped to linear gain 1.0 - 2.0

// The lower part of the slider 0.0 - 0.8 is mapped to a power function that approximates a log curve between 0.0 - 1.0

//

// +---------+-----------------+-------+--------------+

// | Dynamic | a | b | Approximation|

// | range | | | |

// +---------+-----------------+-------+--------------+

// | 50 dB | 3.1623e-3 | 5.757 | x^3 |

// | 60 dB | 1e-3 | 6.908 | x^4 |

// | 70 dB | 3.1623e-4 | 8.059 | x^5 |

// | 80 dB | 1e-4 | 9.210 | x^6 |

// | 90 dB | 3.1623e-5 | 10.36 | x^6 |

// | 100 dB | 1e-5 | 11.51 | x^7 |

// +---------+-----------------+-------+--------------+

// Table 1: Values for a and b in the equation a·exp(b·x)

//

// https://www.dr-lex.be/info-stuff/volumecontrols.html

if (targetGain <= 0.8f)

mappedTargetGain = pow(jmap(targetGain, 0.0f, 0.8f, 0.0f, 1.0f), 2.5f);

else

mappedTargetGain = jmap(targetGain, 0.8f, 1.0f, 1.0f, 2.0f);

// apply smoothing to the main volume control

smoothedGain.setTargetValue(mappedTargetGain);

smoothedGain.applyGain(buffer, buffer.getNumSamples());

midiDeviceManager.sendAndCollectMidiOutput(midiBuffer);

auto const internalSynthPort = midiDeviceManager.getInternalSynthPort();

// If the internalSynth is enabled and loaded, let it process the midi

if (internalSynthPort >= 0 && internalSynth->isReady()) {

midiBufferInternalSynth.clear();

midiDeviceManager.dequeueMidiOutput(internalSynthPort, midiBufferInternalSynth, blockOut.getNumSamples());

internalSynth->process(buffer, midiBufferInternalSynth);

} else if (internalSynthPort < 0 && internalSynth->isReady()) {

internalSynth->unprepare();

} else if (internalSynthPort >= 0 && !internalSynth->isReady()) {

internalSynth->prepare(getSampleRate(), AudioProcessor::getBlockSize());

}

midiBufferInternalSynth.clear();

midiInputHistory.addEvents(midiDeviceManager.getInputHistory(), 0, buffer.getNumSamples(), 0);

statusbarSource->process(midiInputHistory, midiDeviceManager.getOutputHistory());

midiDeviceManager.clearMidiOutputBuffers(blockOut.getNumSamples());

statusbarSource->setCPUUsage(cpuLoadMeasurer.getLoadAsPercentage());

statusbarSource->peakBuffer.write(buffer);

if (enableLimiter && buffer.getNumChannels() > 0) {

// Take out inf and NaN values

auto* const* writePtr = buffer.getArrayOfWritePointers();

for (int ch = 0; ch < buffer.getNumChannels(); ch++) {

for (int n = 0; n < buffer.getNumSamples(); n++) {

if (!std::isfinite(writePtr[ch][n])) {

writePtr[ch][n] = 0.0f;

}

}

}

auto block = dsp::AudioBlock<float>(buffer);

limiter.process(block);

}

// If we miss 4 audio blocks, start the backup scheduler

if(!ProjectInfo::isStandalone) {

backupLoopLock.enter();

backupRunLoop.startTimer(backupRunLoopInterval * 4);

backupLoopLock.exit();

}

isProcessingAudio = false;

{

int const pdBlockSize = Instance::getBlockSize();

int const numBlocks = buffer.getNumSamples() / pdBlockSize;

for (int block = 0; block < numBlocks; block++) {

if (producesMidi()) {

midiByteIndex = 0;

midiByteBuffer[0] = 0;

midiByteBuffer[1] = 0;

midiByteBuffer[2] = 0;

}

midiDeviceManager.dequeueMidiInput(pdBlockSize, [this](int const port, MidiBuffer const& buffer) {

sendMidiBuffer(port, buffer);

});

for (int ch = 0; ch < buffer.getNumChannels(); ch++) {

// Copy the channel data into the vector

juce::FloatVectorOperations::copy(

audioVectorIn.data() + ch * pdBlockSize,

buffer.getChannelPointer(ch) + audioAdvancement,

pdBlockSize);

}

setThis();

sendParameters();

sendMessagesFromQueue();

// Process audio

performDSP(audioVectorIn.data(), audioVectorOut.data());

if (connectionListener && plugdata_debugging_enabled())

connectionListener.load()->updateSignalData();

for (int ch = 0; ch < buffer.getNumChannels(); ch++) {

// Use FloatVectorOperations to copy the vector data into the audioBuffer

juce::FloatVectorOperations::copy(

buffer.getChannelPointer(ch) + audioAdvancement,

audioVectorOut.data() + ch * pdBlockSize,