PluginProcessor.cpp

#include "PluginProcessor.h"
#include "PluginEditor.h"
#include "MovementIn.h"
#include "SensorToAudio.cpp"
#include "Logger.h"

//==============================================================================
EnvironmentalInstrumentsAudioProcessor::EnvironmentalInstrumentsAudioProcessor()
    : AudioProcessor (
        BusesProperties().withOutput("Output", juce::AudioChannelSet::stereo(), true)),
        movementIn(std::make_unique<MovementIn>(*this)),
        sensorToAudio(std::make_unique<SensorToAudio>(*movementIn))
{
    // Set up the bus layout for standalone and plugin modes
    BusesLayout layout;
    if (wrapperType == AudioProcessor::WrapperType::wrapperType_Standalone)
    {
        // Stereo for the standalone
        layout.outputBuses.add(juce::AudioChannelSet::stereo());
    }
    else
    {
        // Otherwise, mono output for plugin versions
        layout.outputBuses.add(juce::AudioChannelSet::mono());
    }
    setBusesLayout(layout);

    logMessage("Version " + std::to_string(PROJECT_VERSION_MAJOR) + "." 
                          + std::to_string(PROJECT_VERSION_MINOR) + "." 
                          + std::to_string(PROJECT_VERSION_PATCH));
    // Show build info to make sure we actually built
    logMessage("Build " __DATE__ " " __TIME__ " " CMAKE_BUILD_TYPE);

    // tell OpenMP (libtorch) threads to not spin CPU when doing nothing
    setenv("OMP_WAIT_POLICY", "PASSIVE", 1);
    backend = std::make_unique<Backend>();
    logMessage("backend initialized...");
}

EnvironmentalInstrumentsAudioProcessor::~EnvironmentalInstrumentsAudioProcessor()
{
    movementIn->stopPolling();
}

//==============================================================================
const juce::String EnvironmentalInstrumentsAudioProcessor::getName() const
{
    return JucePlugin_Name;
}

bool EnvironmentalInstrumentsAudioProcessor::acceptsMidi() const
{
   #if JucePlugin_WantsMidiInput
    return true;
   #else
    return false;
   #endif
}

bool EnvironmentalInstrumentsAudioProcessor::producesMidi() const
{
   #if JucePlugin_ProducesMidiOutput
    return true;
   #else
    return false;
   #endif
}

bool EnvironmentalInstrumentsAudioProcessor::isMidiEffect() const
{
   #if JucePlugin_IsMidiEffect
    return true;
   #else
    return false;
   #endif
}

double EnvironmentalInstrumentsAudioProcessor::getTailLengthSeconds() const
{
    return 0.0;
}

int EnvironmentalInstrumentsAudioProcessor::getNumPrograms()
{
    return 1;   // NB: some hosts don't cope very well if you tell them there are 0 programs,
                // so this should be at least 1, even if you're not really implementing programs.
}

int EnvironmentalInstrumentsAudioProcessor::getCurrentProgram()
{
    return 0;
}

void EnvironmentalInstrumentsAudioProcessor::setCurrentProgram (int index)
{
    juce::ignoreUnused (index);
}

const juce::String EnvironmentalInstrumentsAudioProcessor::getProgramName (int index)
{
    juce::ignoreUnused (index);
    return {};
}

void EnvironmentalInstrumentsAudioProcessor::changeProgramName (int index, const juce::String& newName)
{
    juce::ignoreUnused (index, newName);
}

bool EnvironmentalInstrumentsAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const
{
    // This is the place where you check if the layout is supported.
    // In this template code we only support mono or stereo.
    // Some plugin hosts, such as certain GarageBand versions, will only
    // load plugins that support stereo bus layouts.
    if (layouts.getMainOutputChannelSet() != juce::AudioChannelSet::mono()
     && layouts.getMainOutputChannelSet() != juce::AudioChannelSet::stereo())
        return false;

    return true;
}

//==============================================================================
void EnvironmentalInstrumentsAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
{
    auto logger = Logger::getLogger();
    static auto spid = Logger::createSignpost();

    movementIn->startPolling();

    // pre-playback initialisation
    audioBufferNumSamples = samplesPerBlock;

    // Load model
    juce::File modelFile = juce::File::getSpecialLocation(juce::File::currentExecutableFile)
                                .getParentDirectory()
                                .getParentDirectory()
                                .getChildFile("Resources/cornellbird_causal_epoch373_0.99.ts");

    if (modelFile.existsAsFile())
    {
        if (backend->load(modelFile.getFullPathName().toStdString()))
            logMessage("Model load error.");
        else
            logMessage("Model loaded.");
    }
    else
    {
        logMessage("Model file not found!");
    }
    if (!backend->is_loaded()) return;

    auto modelParams = backend->get_method_params("decode");
    // Get from model params
    sizeModelWindow = modelParams[1];
    assert(sizeModelWindow > 0);
    modelOutputChannels = modelParams[2];
    backend->prepare(modelOutputChannels, "decode");

    int modelInputDim = modelParams[0];

    // size of buffers 
    // - input ceiling(audioBufferNumSamples/sizeModelWindow)
    // - output ceiling(audioBufferNumSamples/sizeModelWindow) * sizeModelWindow
    // Pre-allocate model in/out buffers
    int bs = (audioBufferNumSamples + sizeModelWindow - 1) / sizeModelWindow;
    modelInput.setSize(modelInputDim, bs);
    modelOutput.setSize(modelOutputChannels, bs * sizeModelWindow);
    // This will be transferred to audio out when model runs, so shouldn't contain garbage
    modelOutput.clear();

    // initialize model out buffer
    modelOutputBuffer = std::make_unique<circular_buffer<float>[]>(static_cast<size_t>(modelOutputChannels));
    for (int c(0); c < modelOutputChannels; c++)
        // make sure buffer is big enough to store model window and audio buffer plus some (to allow for audio callback jitter)
        modelOutputBuffer[static_cast<size_t>(c)].initialize(static_cast<size_t>(bs * sizeModelWindow * 2));

    // Pre-allocate pointer vectors with number of channels
    modelInputPts.reserve(static_cast<size_t>(modelInputDim));
    modelOutputPts.reserve(static_cast<size_t>(modelOutputChannels));
    modelInputPts.clear();
    modelOutputPts.clear();

    // Fill with pointers to model buffers
    for (int c = 0; c < modelInputDim; ++c)
    {
        modelInputPts.push_back(const_cast<float*>(modelInput.getReadPointer(c)));
    }
    for (int c = 0; c < modelOutputChannels; ++c)
    {
        modelOutputPts.push_back(modelOutput.getWritePointer(c));
    }

    // prepare to fill circular buffer with sensor data
    sensorToAudio->prepareToPlay(sampleRate, sizeModelWindow, audioBufferNumSamples);
    runAudio = false;

    // flush some water through the model to clear the pipes
    for (int i(0); i < 3; i++)
    {
        os_signpost_interval_begin(logger, spid, "Model warmup run", "");
        backend->perform(modelInputPts, modelOutputPts, 1, "decode", 1);
        os_signpost_interval_end(logger, spid, "Model warmup run", "");
    }

    shouldStopBackend = false;
    backendThread = std::make_unique<std::thread>(
        &EnvironmentalInstrumentsAudioProcessor::runBackend, 
        this
    );

    sensorToAudio->startPolling();
}

void EnvironmentalInstrumentsAudioProcessor::releaseResources()
{
    auto logger = Logger::getLogger();
    static auto spid = Logger::createSignpost();
    os_signpost_interval_begin(logger, spid, "AudioProcessor release resources", "");
    shouldStopBackend = true;
    sensorToAudio->stopPolling();
    if (backendThread && backendThread->joinable())
        {
            os_signpost_interval_begin(logger, spid, "AudioProcessor join backend thread", "");
            backendThread->join();
            os_signpost_interval_end(logger, spid, "AudioProcessor join backend thread", "");
            backendThread.reset();
        }

    os_signpost_interval_end(logger, spid, "AudioProcessor release resources", "");
}

// run backend loop
void EnvironmentalInstrumentsAudioProcessor::runBackend()
{
    auto logger = Logger::getLogger();
    static auto spid = Logger::createSignpost();

    int samplesRead;
    while (!shouldStopBackend)
    {
        sensorToAudio->waitFlushBuffer(modelInput, samplesRead, shouldStopBackend);
        if (shouldStopBackend)
            return;

        assert(samplesRead > 0);
        os_signpost_interval_begin(logger, spid, "Process backend", "%d samples to process", samplesRead);
        backend->perform(modelInputPts, modelOutputPts, samplesRead, "decode", 1);
        os_signpost_interval_end(logger, spid, "Process backend", "");

        // transfer from model out buffer to out circular buffer
        // needs to be thread-safe
        std::lock_guard<std::mutex> lock(mobLock);
        for (int c(0); c < modelOutputChannels; c++)
            modelOutputBuffer[static_cast<size_t>(c)].put(modelOutput.getReadPointer(c), samplesRead * sizeModelWindow);
    }
}

void EnvironmentalInstrumentsAudioProcessor::processBlock (juce::AudioBuffer<float>& outBuffer,
                                              juce::MidiBuffer& midiMessages)
{
    juce::ignoreUnused (midiMessages);
    juce::ScopedNoDenormals noDenormals;

    auto logger = Logger::getLogger();
    static auto spid = Logger::createSignpost();

    if (!backend->is_loaded())
    {
        outBuffer.clear();
        return;
    }

    {
        std::lock_guard<std::mutex> lock(mobLock);
        mobAvailable = static_cast<int>(modelOutputBuffer[0].size());
        // wait until circular buffer can fill audio buffer to start consuming
        if (!runAudio)
        {
            if (mobAvailable >= audioBufferNumSamples)
            {
                runAudio = true;
                os_signpost_event_emit(logger, spid, "Audio playback started", "");
            }
        }
        if (runAudio)
        {
            // transfer from out circular buffer to audio out buffer
            for (int c(0); c < outBuffer.getNumChannels(); c++)
            {
                // check if our output channel is greater than channels supplied by model output
                if (c >= modelOutputChannels)
                    // copy last channel supplied by model into all remaining channels
                    outBuffer.copyFrom(c, 0, outBuffer, c - 1, 0, audioBufferNumSamples);
                else
                    modelOutputBuffer[static_cast<size_t>(c)].get(outBuffer.getWritePointer(c), audioBufferNumSamples);
            }
            // if buffer runs out, sensorToAudio has stopped supplying, so wait again
            if (mobAvailable < audioBufferNumSamples)
            {
                runAudio = false;
                os_signpost_event_emit(logger, spid, "Buffer underrun, audio playback stopped", "");
            }
        }
    }
}

//==============================================================================
bool EnvironmentalInstrumentsAudioProcessor::hasEditor() const
{
    return true; // (change this to false if you choose to not supply an editor)
}

juce::AudioProcessorEditor* EnvironmentalInstrumentsAudioProcessor::createEditor()
{
    return new EnvironmentalInstrumentsAudioProcessorEditor (*this);
}

//==============================================================================
void EnvironmentalInstrumentsAudioProcessor::getStateInformation (juce::MemoryBlock& destData)
{
    // You should use this method to store your parameters in the memory block.
    // You could do that either as raw data, or use the XML or ValueTree classes
    // as intermediaries to make it easy to save and load complex data.
    juce::ignoreUnused (destData);
}

void EnvironmentalInstrumentsAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
{
    // You should use this method to restore your parameters from this memory block,
    // whose contents will have been created by the getStateInformation() call.
    juce::ignoreUnused (data, sizeInBytes);
}

EnvironmentalInstrumentsAudioProcessor::UIState EnvironmentalInstrumentsAudioProcessor::getLockUiState()
{
    std::unique_lock<std::mutex> tempLock(uiStateMutex);  // Lock the mutex
    uiStateLock = std::move(tempLock);  // Transfer ownership of the lock to the class member

    return uiState;
}

EnvironmentalInstrumentsAudioProcessor::UIState EnvironmentalInstrumentsAudioProcessor::getUiState()
{
    std::lock_guard<std::mutex> lock(uiStateMutex);
    return uiState;
}

void EnvironmentalInstrumentsAudioProcessor::setEditor(EnvironmentalInstrumentsAudioProcessorEditor *editor)
{
    pluginEditor = editor;
    if (uiStateLock.owns_lock()) {  // Check if it's currently locked
        uiStateLock.unlock();  // Unlock the mutex
    }
}

void EnvironmentalInstrumentsAudioProcessor::destroyEditor()
{
    pluginEditor = nullptr;
}

void EnvironmentalInstrumentsAudioProcessor::logMessage(const juce::String &message)
{
    juce::ScopedLock loglock(logLock);
    std::lock_guard<std::mutex> uilock(uiStateMutex);
    // append message to UI log text
    uiState.logText += message + "\n";
    // log to editor if exists
    if (pluginEditor) pluginEditor->logMessage(message);
}

void EnvironmentalInstrumentsAudioProcessor::updateJoyConConnectionStatus(const bool leftJC, const bool rightJC)
{
    std::lock_guard<std::mutex> lock(uiStateMutex);
    uiState.lConnected = leftJC;
    uiState.rConnected = rightJC;
    if (pluginEditor) pluginEditor->showJCConnectionStatus();
}

//==============================================================================
// This creates new instances of the plugin..
juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
    return new EnvironmentalInstrumentsAudioProcessor();
}