{

#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::canonicalChannelSet(16), true);

busesProperties.addBus(false, "Main Output", AudioChannelSet::canonicalChannelSet(16), 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

initialiseFilesystem();

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();

{

auto const& homeDir = ProjectInfo::appDataDir;

auto const& versionDataDir = ProjectInfo::versionDataDir;

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

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

#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();

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

if (!versionDataDir.exists()) {

// 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<char> 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();

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

// Decompress .xz data using liblzma

HeapArray<uint8_t> decompressedData;

decompressedData.reserve(40 * 1024 * 1024);

{

lzma_stream strm = LZMA_STREAM_INIT;

if (lzma_stream_decoder(&strm, UINT64_MAX, 0) != LZMA_OK)

return; // TODO: handle failure!

strm.next_in = reinterpret_cast<const uint8_t*>(allData.data());

strm.avail_in = allData.size();

uint8_t buffer[8192];

lzma_ret ret;

do {

strm.next_out = buffer;

strm.avail_out = sizeof(buffer);

ret = lzma_code(&strm, LZMA_FINISH);

size_t written = sizeof(buffer) - strm.avail_out;

decompressedData.insert(decompressedData.end(), buffer, buffer + written);

if (ret != LZMA_OK && ret != LZMA_STREAM_END) {

lzma_end(&strm);

return; // TODO: handle failure!

}

} while (ret != LZMA_STREAM_END);

lzma_end(&strm);

}

// Parse and extract .tar manually

auto extractTar = [](const uint8_t* data, size_t size, const File& destRoot) -> bool {

size_t offset = 0;

while (offset + 512 <= size) {

const uint8_t* header = data + offset;

if (header[0] == '\0') break; // End of archive

// Get file name

std::string name(reinterpret_cast<const char*>(header), 100);

if (name.empty()) break;

// Get file size (octal)

size_t fileSize = std::strtoull(reinterpret_cast<const char*>(header + 124), nullptr, 8);

File outFile = destRoot.getChildFile(String(name));

// Determine type

char typeFlag = header[156];

if (typeFlag == '5') {

outFile.createDirectory();

} else if (typeFlag == '0' || typeFlag == '\0') {

outFile.getParentDirectory().createDirectory();

std::ofstream out(outFile.getFullPathName().toRawUTF8(), std::ios::binary);

size_t fileOffset = offset + 512;

out.write(reinterpret_cast<const char*>(data + fileOffset), fileSize);

out.close();

}

size_t totalEntrySize = 512 + ((fileSize + 511) & ~511); // pad to next 512

offset += totalEntrySize;

}

return true;

};

versionDataDir.getParentDirectory().createDirectory();

if (!extractTar(decompressedData.data(), decompressedData.size(), tempVersionDataDir.getParentDirectory())) {

DBG("Failed to extract tar archive");

return;

}

// Create filesystem for this specific version

tempVersionDataDir.moveFileTo(versionDataDir);

}

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);

// We want to recreate these symlinks so that they link to the abstractions/docs for the current plugdata version

homeDir.getChildFile("Abstractions").deleteFile();

homeDir.getChildFile("Documentation").deleteFile();

homeDir.getChildFile("Extra").deleteFile();

// 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("/", "\\");

auto dekenPath = dekenDir.getFullPathName();

auto patchesPath = patchesDir.getFullPathName();

// Create NTFS directory junctions

OSUtils::createJunction(homeDir.getChildFile("Abstractions").getFullPathName().replaceCharacters("/", "\\").toStdString(), abstractionsPath.toStdString());

OSUtils::createJunction(homeDir.getChildFile("Documentation").getFullPathName().replaceCharacters("/", "\\").toStdString(), documentationPath.toStdString());

OSUtils::createJunction(homeDir.getChildFile("Extra").getFullPathName().replaceCharacters("/", "\\").toStdString(), extraPath.toStdString());

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

versionDataDir.getChildFile("Abstractions").createSymbolicLink(homeDir.getChildFile("Abstractions"), true);

versionDataDir.getChildFile("Documentation").createSymbolicLink(homeDir.getChildFile("Documentation"), true);

versionDataDir.getChildFile("Extra").createSymbolicLink(homeDir.getChildFile("Extra"), true);

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

docsPatchesDir.createDirectory();

if (!patchesDir.isSymbolicLink()) {

patchesDir.deleteRecursively();

} else {

patchesDir.deleteFile();

}

docsPatchesDir.createSymbolicLink(patchesDir, true);

#else

versionDataDir.getChildFile("Abstractions").createSymbolicLink(homeDir.getChildFile("Abstractions"), true);

versionDataDir.getChildFile("Documentation").createSymbolicLink(homeDir.getChildFile("Documentation"), true);

versionDataDir.getChildFile("Extra").createSymbolicLink(homeDir.getChildFile("Extra"), true);

#endif

initMutex.deleteFile();

{

// 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, samplesPerBlock * 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, maxChannels);

}

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 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());

{

ScopedNoDenormals noDenormals;

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

auto const totalNumInputChannels = getTotalNumInputChannels();

auto const totalNumOutputChannels = getTotalNumOutputChannels();

auto midiInputHistory = midiBuffer;

setThis();

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(), std::max(totalNumInputChannels, totalNumOutputChannels));

}

midiBufferInternalSynth.clear();

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

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

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);

}

{

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, int const blockSize, MidiBuffer& 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,

pdBlockSize);

}

audioAdvancement += pdBlockSize;

}

audioAdvancement = 0;

{

auto const pdBlockSize = Instance::getBlockSize();

auto const numChannels = buffer.getNumChannels();

inputFifo->writeAudioAndMidi(buffer, midiBuffer);

audioAdvancement = 0; // Always has to be 0 if we use the AudioMidiFifo!

while (outputFifo->getNumSamplesAvailable() < buffer.getNumSamples()) {

if (producesMidi()) {

midiByteIndex = 0;

midiByteBuffer[0] = 0;

midiByteBuffer[1] = 0;

midiByteBuffer[2] = 0;

}

blockMidiBuffer.clear();

inputFifo->readAudioAndMidi(audioBufferIn, blockMidiBuffer);

if (!ProjectInfo::isStandalone) {

sendMidiBuffer(1, blockMidiBuffer);

}

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

sendMidiBuffer(port, buffer);

});

for (int channel = 0; channel < audioBufferIn.getNumChannels(); channel++) {

// Copy the channel data into the vector

juce::FloatVectorOperations::copy(

audioVectorIn.data() + channel * pdBlockSize,

audioBufferIn.getReadPointer(channel),

pdBlockSize);

}

setThis();

sendParameters();

sendMessagesFromQueue();

// Process audio

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

if (connectionListener && plugdata_debugging_enabled())

connectionListener.load()->updateSignalData();

for (int channel = 0; channel < numChannels; channel++) {

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

juce::FloatVectorOperations::copy(

audioBufferOut.getWritePointer(channel),

audioVectorOut.data() + channel * pdBlockSize,

pdBlockSize);

}

blockMidiBuffer.clear();

outputFifo->writeAudioAndMidi(audioBufferOut, blockMidiBuffer);

}

midiBuffer.clear();

outputFifo->readAudioAndMidi(buffer, midiBuffer);

{

AudioPlayHead const* playhead = getPlayHead();

if (!playhead)

return;

auto infos = playhead->getPosition();

lockAudioThread();

setThis();

if (infos.hasValue()) {

atoms_playhead[0] = static_cast<float>(infos->getIsPlaying());

sendMessage("__playhead", "playing", atoms_playhead);

atoms_playhead[0] = static_cast<float>(infos->getIsRecording());

sendMessage("__playhead", "recording", atoms_playhead);

atoms_playhead[0] = static_cast<float>(infos->getIsLooping());

auto loopPoints = infos->getLoopPoints();

if (loopPoints.hasValue()) {

atoms_playhead.emplace_back(static_cast<float>(loopPoints->ppqStart));

atoms_playhead.emplace_back(static_cast<float>(loopPoints->ppqEnd));

} else {

atoms_playhead.emplace_back(0.0f);

atoms_playhead.emplace_back(0.0f);

}

sendMessage("__playhead", "looping", atoms_playhead);

if (infos->getEditOriginTime().hasValue()) {

atoms_playhead.resize(1);

atoms_playhead[0] = static_cast<float>(*infos->getEditOriginTime());

sendMessage("__playhead", "edittime", atoms_playhead);

}

if (infos->getFrameRate().hasValue()) {

atoms_playhead.resize(1);

atoms_playhead[0] = static_cast<float>(infos->getFrameRate()->getEffectiveRate());

sendMessage("__playhead", "framerate", atoms_playhead);

}

if (infos->getBpm().hasValue()) {

atoms_playhead.resize(1);

atoms_playhead[0] = static_cast<float>(*infos->getBpm());

sendMessage("__playhead", "bpm", atoms_playhead);

}

if (infos->getPpqPositionOfLastBarStart().hasValue()) {

atoms_playhead.resize(1);

atoms_playhead[0] = static_cast<float>(*infos->getPpqPositionOfLastBarStart());

sendMessage("__playhead", "lastbar", atoms_playhead);

}

if (infos->getTimeSignature().hasValue()) {

atoms_playhead.resize(1);

atoms_playhead[0] = static_cast<float>(infos->getTimeSignature()->numerator);

atoms_playhead.emplace_back(static_cast<float>(infos->getTimeSignature()->denominator));

sendMessage("__playhead", "timesig", atoms_playhead);

}

auto ppq = infos->getPpqPosition();

auto samplesTime = infos->getTimeInSamples();

auto secondsTime = infos->getTimeInSeconds();

if (ppq.hasValue() || samplesTime.hasValue() || secondsTime.hasValue()) {

atoms_playhead.resize(3);

atoms_playhead[0] = ppq.hasValue() ? static_cast<float>(*ppq) : 0.0f;

atoms_playhead[1] = samplesTime.hasValue() ? static_cast<float>(*samplesTime) : 0.0f;

atoms_playhead[2] = secondsTime.hasValue() ? static_cast<float>(*secondsTime) : 0.0f;

sendMessage("__playhead", "position", atoms_playhead);

}

atoms_playhead.resize(1);

}

unlockAudioThread();

{

ScopedLock lock(audioLock);

enabledParameters.clear();

for (auto* param : getParameters()) {

if (auto* p = dynamic_cast<PlugDataParameter*>(param)) {

if (p->isEnabled()) {

enabledParameters.add(p);

}

}

}