juce_AudioProcessorPlayer.cpp

Go to the documentation of this file.

 /*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
template <typename Value>
struct ChannelInfo
{
    ChannelInfo() = default;
    ChannelInfo (Value* const* dataIn, int numChannelsIn)
        : data (dataIn), numChannels (numChannelsIn)  {}
 
    Value* const* data = nullptr;
    int numChannels = 0;
};
 
static void initialiseIoBuffers (ChannelInfo<const float> ins,
                                 ChannelInfo<float> outs,
                                 const int numSamples,
                                 int processorIns,
                                 int processorOuts,
                                 AudioBuffer<float>& tempBuffer,
                                 std::vector<float*>& channels)
{
    jassert ((int) channels.size() >= jmax (processorIns, processorOuts));
 
    size_t totalNumChans = 0;
    const auto numBytes = (size_t) numSamples * sizeof (float);
 
    const auto prepareInputChannel = [&] (int index)
    {
        if (ins.numChannels == 0)
            zeromem (channels[totalNumChans], numBytes);
        else
            memcpy (channels[totalNumChans], ins.data[index % ins.numChannels], numBytes);
    };
 
    if (processorIns > processorOuts)
    {
        // If there aren't enough output channels for the number of
        // inputs, we need to use some temporary extra ones (can't
        // use the input data in case it gets written to).
        jassert (tempBuffer.getNumChannels() >= processorIns - processorOuts);
        jassert (tempBuffer.getNumSamples() >= numSamples);
 
        for (int i = 0; i < processorOuts; ++i)
        {
            channels[totalNumChans] = outs.data[i];
            prepareInputChannel (i);
            ++totalNumChans;
        }
 
        for (auto i = processorOuts; i < processorIns; ++i)
        {
            channels[totalNumChans] = tempBuffer.getWritePointer (i - processorOuts);
            prepareInputChannel (i);
            ++totalNumChans;
        }
    }
    else
    {
        for (int i = 0; i < processorIns; ++i)
        {
            channels[totalNumChans] = outs.data[i];
            prepareInputChannel (i);
            ++totalNumChans;
        }
 
        for (auto i = processorIns; i < processorOuts; ++i)
        {
            channels[totalNumChans] = outs.data[i];
            zeromem (channels[totalNumChans], (size_t) numSamples * sizeof (float));
            ++totalNumChans;
        }
    }
}
 
//==============================================================================
AudioProcessorPlayer::AudioProcessorPlayer (bool doDoublePrecisionProcessing)
    : isDoublePrecision (doDoublePrecisionProcessing)
{
}
 
AudioProcessorPlayer::~AudioProcessorPlayer()
{
    setProcessor (nullptr);
}
 
//==============================================================================
AudioProcessorPlayer::NumChannels AudioProcessorPlayer::findMostSuitableLayout (const AudioProcessor& proc) const
{
    if (proc.isMidiEffect())
        return {};
 
    std::vector<NumChannels> layouts { deviceChannels };
 
    if (deviceChannels.ins == 0 || deviceChannels.ins == 1)
    {
        layouts.emplace_back (defaultProcessorChannels.ins, deviceChannels.outs);
        layouts.emplace_back (deviceChannels.outs, deviceChannels.outs);
    }
 
    const auto it = std::find_if (layouts.begin(), layouts.end(), [&] (const NumChannels& chans)
    {
        return proc.checkBusesLayoutSupported (chans.toLayout());
    });
 
    return it != std::end (layouts) ? *it : layouts[0];
}
 
void AudioProcessorPlayer::resizeChannels()
{
    const auto maxChannels = jmax (deviceChannels.ins,
                                   deviceChannels.outs,
                                   actualProcessorChannels.ins,
                                   actualProcessorChannels.outs);
    channels.resize ((size_t) maxChannels);
    tempBuffer.setSize (maxChannels, blockSize);
}
 
void AudioProcessorPlayer::setProcessor (AudioProcessor* const processorToPlay)
{
    const ScopedLock sl (lock);
 
    if (processor == processorToPlay)
        return;
 
    sampleCount = 0;
    currentWorkgroup.reset();
 
    if (processorToPlay != nullptr && sampleRate > 0 && blockSize > 0)
    {
        defaultProcessorChannels = NumChannels { processorToPlay->getBusesLayout() };
        actualProcessorChannels  = findMostSuitableLayout (*processorToPlay);
 
        if (processorToPlay->isMidiEffect())
            processorToPlay->setRateAndBufferSizeDetails (sampleRate, blockSize);
        else
            processorToPlay->setPlayConfigDetails (actualProcessorChannels.ins,
                                                   actualProcessorChannels.outs,
                                                   sampleRate,
                                                   blockSize);
 
        auto supportsDouble = processorToPlay->supportsDoublePrecisionProcessing() && isDoublePrecision;
 
        processorToPlay->setProcessingPrecision (supportsDouble ? AudioProcessor::doublePrecision
                                                                : AudioProcessor::singlePrecision);
 
        processorToPlay->prepareToPlay (sampleRate, blockSize);
    }
 
    AudioProcessor* oldOne = nullptr;
 
    oldOne = isPrepared ? processor : nullptr;
    processor = processorToPlay;
    isPrepared = true;
    resizeChannels();
 
    if (oldOne != nullptr)
        oldOne->releaseResources();
}
 
void AudioProcessorPlayer::setDoublePrecisionProcessing (bool doublePrecision)
{
    if (doublePrecision != isDoublePrecision)
    {
        const ScopedLock sl (lock);
 
        currentWorkgroup.reset();
 
        if (processor != nullptr)
        {
            processor->releaseResources();
 
            auto supportsDouble = processor->supportsDoublePrecisionProcessing() && doublePrecision;
 
            processor->setProcessingPrecision (supportsDouble ? AudioProcessor::doublePrecision
                                                              : AudioProcessor::singlePrecision);
 
            processor->prepareToPlay (sampleRate, blockSize);
        }
 
        isDoublePrecision = doublePrecision;
    }
}
 
void AudioProcessorPlayer::setMidiOutput (MidiOutput* midiOutputToUse)
{
    if (midiOutput != midiOutputToUse)
    {
        const ScopedLock sl (lock);
        midiOutput = midiOutputToUse;
    }
}
 
//==============================================================================
void AudioProcessorPlayer::audioDeviceIOCallbackWithContext (const float* const* const inputChannelData,
                                                             const int numInputChannels,
                                                             float* const* const outputChannelData,
                                                             const int numOutputChannels,
                                                             const int numSamples,
                                                             const AudioIODeviceCallbackContext& context)
{
    const ScopedLock sl (lock);
 
    jassert (currentDevice != nullptr);
 
    // These should have been prepared by audioDeviceAboutToStart()...
    jassert (sampleRate > 0 && blockSize > 0);
 
    incomingMidi.clear();
    messageCollector.removeNextBlockOfMessages (incomingMidi, numSamples);
 
    initialiseIoBuffers ({ inputChannelData,  numInputChannels },
                         { outputChannelData, numOutputChannels },
                         numSamples,
                         actualProcessorChannels.ins,
                         actualProcessorChannels.outs,
                         tempBuffer,
                         channels);
 
    const auto totalNumChannels = jmax (actualProcessorChannels.ins, actualProcessorChannels.outs);
    AudioBuffer<float> buffer (channels.data(), (int) totalNumChannels, numSamples);
 
    if (processor != nullptr)
    {
        // The processor should be prepared to deal with the same number of output channels
        // as our output device.
        jassert (processor->isMidiEffect() || numOutputChannels == actualProcessorChannels.outs);
 
        const ScopedLock sl2 (processor->getCallbackLock());
 
        if (std::exchange (currentWorkgroup, currentDevice->getWorkgroup()) != currentDevice->getWorkgroup())
            processor->audioWorkgroupContextChanged (currentWorkgroup);
 
        class PlayHead final : private AudioPlayHead
        {
        public:
            PlayHead (AudioProcessor& proc,
                      Optional<uint64_t> hostTimeIn,
                      uint64_t sampleCountIn,
                      double sampleRateIn)
                : processor (proc),
                  hostTimeNs (hostTimeIn),
                  sampleCount (sampleCountIn),
                  seconds ((double) sampleCountIn / sampleRateIn)
            {
                if (useThisPlayhead)
                    processor.setPlayHead (this);
            }
 
            ~PlayHead() override
            {
                if (useThisPlayhead)
                    processor.setPlayHead (nullptr);
            }
 
        private:
            Optional<PositionInfo> getPosition() const override
            {
                PositionInfo info;
                info.setHostTimeNs (hostTimeNs);
                info.setTimeInSamples ((int64_t) sampleCount);
                info.setTimeInSeconds (seconds);
                return info;
            }
 
            AudioProcessor& processor;
            Optional<uint64_t> hostTimeNs;
            uint64_t sampleCount;
            double seconds;
            bool useThisPlayhead = processor.getPlayHead() == nullptr;
        };
 
        PlayHead playHead { *processor,
                            context.hostTimeNs != nullptr ? makeOptional (*context.hostTimeNs) : nullopt,
                            sampleCount,
                            sampleRate };
 
        sampleCount += (uint64_t) numSamples;
 
        if (! processor->isSuspended())
        {
            if (processor->isUsingDoublePrecision())
            {
                conversionBuffer.makeCopyOf (buffer, true);
                processor->processBlock (conversionBuffer, incomingMidi);
                buffer.makeCopyOf (conversionBuffer, true);
            }
            else
            {
                processor->processBlock (buffer, incomingMidi);
            }
 
            if (midiOutput != nullptr)
            {
                if (midiOutput->isBackgroundThreadRunning())
                {
                    midiOutput->sendBlockOfMessages (incomingMidi,
                                                     Time::getMillisecondCounterHiRes(),
                                                     sampleRate);
                }
                else
                {
                    midiOutput->sendBlockOfMessagesNow (incomingMidi);
                }
            }
 
            return;
        }
    }
 
    for (int i = 0; i < numOutputChannels; ++i)
        FloatVectorOperations::clear (outputChannelData[i], numSamples);
}
 
void AudioProcessorPlayer::audioDeviceAboutToStart (AudioIODevice* const device)
{
    currentDevice = device;
    auto newSampleRate = device->getCurrentSampleRate();
    auto newBlockSize  = device->getCurrentBufferSizeSamples();
    auto numChansIn    = device->getActiveInputChannels().countNumberOfSetBits();
    auto numChansOut   = device->getActiveOutputChannels().countNumberOfSetBits();
 
    const ScopedLock sl (lock);
 
    sampleRate = newSampleRate;
    blockSize  = newBlockSize;
    deviceChannels = { numChansIn, numChansOut };
 
    resizeChannels();
 
    messageCollector.reset (sampleRate);
 
    currentWorkgroup.reset();
 
    if (processor != nullptr)
    {
        if (isPrepared)
            processor->releaseResources();
 
        auto* oldProcessor = processor;
        setProcessor (nullptr);
        setProcessor (oldProcessor);
    }
}
 
void AudioProcessorPlayer::audioDeviceStopped()
{
    const ScopedLock sl (lock);
 
    if (processor != nullptr && isPrepared)
        processor->releaseResources();
 
    sampleRate = 0.0;
    blockSize = 0;
    isPrepared = false;
    tempBuffer.setSize (1, 1);
 
    currentDevice = nullptr;
    currentWorkgroup.reset();
}
 
void AudioProcessorPlayer::handleIncomingMidiMessage (MidiInput*, const MidiMessage& message)
{
    messageCollector.addMessageToQueue (message);
}
 
//==============================================================================
//==============================================================================
#if JUCE_UNIT_TESTS
 
struct AudioProcessorPlayerTests final : public UnitTest
{
    AudioProcessorPlayerTests()
        : UnitTest ("AudioProcessorPlayer", UnitTestCategories::audio) {}
 
    void runTest() override
    {
        struct Layout
        {
            int numIns, numOuts;
        };
 
        const Layout processorLayouts[] { Layout { 0, 0 },
                                          Layout { 1, 1 },
                                          Layout { 4, 4 },
                                          Layout { 4, 8 },
                                          Layout { 8, 4 } };
 
        beginTest ("Buffers are prepared correctly for a variety of channel layouts");
        {
            for (const auto& layout : processorLayouts)
            {
                for (const auto numSystemInputs : { 0, 1, layout.numIns })
                {
                    const int numSamples = 256;
                    const auto systemIns = getTestBuffer (numSystemInputs, numSamples);
                    auto systemOuts = getTestBuffer (layout.numOuts, numSamples);
                    AudioBuffer<float> tempBuffer (jmax (layout.numIns, layout.numOuts), numSamples);
                    std::vector<float*> channels ((size_t) jmax (layout.numIns, layout.numOuts), nullptr);
 
                    initialiseIoBuffers ({ systemIns.getArrayOfReadPointers(),   systemIns.getNumChannels() },
                                         { systemOuts.getArrayOfWritePointers(), systemOuts.getNumChannels() },
                                         numSamples,
                                         layout.numIns,
                                         layout.numOuts,
                                         tempBuffer,
                                         channels);
 
                    int channelIndex = 0;
 
                    for (const auto& channel : channels)
                    {
                        const auto value = [&]
                        {
                            // Any channels past the number of inputs should be silent.
                            if (layout.numIns <= channelIndex)
                                return 0.0f;
 
                            // If there's no input, all input channels should be silent.
                            if (numSystemInputs == 0)       return 0.0f;
 
                            // If there's one input, all input channels should copy from that input.
                            if (numSystemInputs == 1)       return 1.0f;
 
                            // Otherwise, each processor input should match the corresponding system input.
                            return (float) (channelIndex + 1);
                        }();
 
                        expect (FloatVectorOperations::findMinAndMax (channel, numSamples) == Range<float> (value, value));
 
                        channelIndex += 1;
                    }
                }
            }
        }
    }
 
    static AudioBuffer<float> getTestBuffer (int numChannels, int numSamples)
    {
        AudioBuffer<float> result (numChannels, numSamples);
 
        for (int i = 0; i < result.getNumChannels(); ++i)
            FloatVectorOperations::fill (result.getWritePointer (i), (float) i + 1, result.getNumSamples());
 
        return result;
    }
};
 
static AudioProcessorPlayerTests audioProcessorPlayerTests;
 
#endif
 
} // namespace juce