tracktion_AudioBufferPool.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
 
namespace tracktion { inline namespace graph
{
#include "../3rd_party/farbot/include/farbot/fifo.hpp"
}}
 
namespace tracktion { inline namespace graph
{
 
//==============================================================================
class AudioBufferPool
{
public:
    AudioBufferPool() = default;
 
    AudioBufferPool (size_t maxCapacity);
 
    choc::buffer::ChannelArrayBuffer<float> allocate (choc::buffer::Size);
 
    bool release (choc::buffer::ChannelArrayBuffer<float>&&);
 
    //==============================================================================
    void reset();
 
    void setCapacity (size_t);
 
    size_t getCapacity() const                      { return capacity; }
 
    void reserve (size_t numBuffers, choc::buffer::Size);
 
    //==============================================================================
    size_t getNumBuffers();
 
    size_t getAllocatedSize();
 
private:
    std::unique_ptr<farbot::fifo<choc::buffer::ChannelArrayBuffer<float>>> fifo;
    size_t capacity = 0;
};
 
 
//==============================================================================
//        _        _           _  _
//     __| |  ___ | |_   __ _ (_)| | ___
//    / _` | / _ \| __| / _` || || |/ __|
//   | (_| ||  __/| |_ | (_| || || |\__ \ _  _  _
//    \__,_| \___| \__| \__,_||_||_||___/(_)(_)(_)
//
//   Code beyond this point is implementation detail...
//
//==============================================================================
inline AudioBufferPool::AudioBufferPool (size_t maxCapacity)
{
    setCapacity (maxCapacity);
}
 
inline choc::buffer::ChannelArrayBuffer<float> AudioBufferPool::allocate (choc::buffer::Size size)
{
    choc::buffer::ChannelArrayBuffer<float> buffer;
 
    if (fifo->pop (buffer))
    {
        if (auto bufferSize = buffer.getSize();
            bufferSize.numChannels < size.numChannels
            || bufferSize.numFrames < size.numFrames)
        {
            buffer.resize (size);
        }
    }
    else
    {
        buffer.resize (size);
    }
 
    return buffer;
}
 
inline bool AudioBufferPool::release (choc::buffer::ChannelArrayBuffer<float>&& buffer)
{
    return fifo->push (std::move (buffer));
}
 
//==============================================================================
inline void  AudioBufferPool::setCapacity (size_t maxCapacity)
{
    maxCapacity = (size_t) juce::nextPowerOfTwo ((int) maxCapacity);
 
    if (maxCapacity <= capacity)
        return;
 
    fifo = std::make_unique<farbot::fifo<choc::buffer::ChannelArrayBuffer<float>>> ((int) maxCapacity);
    capacity = maxCapacity;
}
 
inline void AudioBufferPool::reserve (size_t numBuffers, choc::buffer::Size size)
{
    std::vector<choc::buffer::ChannelArrayBuffer<float>> buffers;
 
    // Remove all the buffers
    for (;;)
    {
        choc::buffer::ChannelArrayBuffer<float> tempBuffer;
 
        if (! fifo->pop (tempBuffer))
            break;
 
        buffers.emplace_back (std::move (tempBuffer));
    }
 
    // Ensure their size is as big as required
    for (auto& b : buffers)
    {
        if (auto bufferSize = b.getSize();
            bufferSize.numChannels < size.numChannels
            || bufferSize.numFrames < size.numFrames)
        {
            b.resize (size);
        }
    }
 
    // Reset the fifo storage to hold the new number of buffers
    const int numToAdd = static_cast<int> (numBuffers) - static_cast<int> (buffers.size());
 
    // Push the temp buffers back
    for (auto& b : buffers)
    {
        [[ maybe_unused ]] bool succeeded = release (std::move (b));
        assert (succeeded); // Capacity too small?
    }
 
    // Push any additional buffers
    for (int i = 0; i < numToAdd; ++i)
    {
        [[ maybe_unused ]] bool succeeded = release (choc::buffer::ChannelArrayBuffer<float> (size));
        assert (succeeded); // Capacity too small?
    }
}
 
inline size_t AudioBufferPool::getNumBuffers()
{
    std::vector<choc::buffer::ChannelArrayBuffer<float>> buffers;
 
    // Remove all the buffers
    for (;;)
    {
        choc::buffer::ChannelArrayBuffer<float> tempBuffer;
 
        if (! fifo->pop (tempBuffer))
            break;
 
        buffers.emplace_back (std::move (tempBuffer));
    }
 
    const auto numBuffers = buffers.size();
 
    // Push the temp buffers back
    for (auto& b : buffers)
    {
        [[ maybe_unused ]] bool succeeded = release (std::move (b));
        assert (succeeded);
    }
 
    return numBuffers;
}
 
inline size_t AudioBufferPool::getAllocatedSize()
{
    size_t size = 0;
    std::vector<choc::buffer::ChannelArrayBuffer<float>> buffers;
 
    // Remove all the buffers
    for (;;)
    {
        choc::buffer::ChannelArrayBuffer<float> tempBuffer;
 
        if (! fifo->pop (tempBuffer))
            break;
 
        buffers.emplace_back (std::move (tempBuffer));
    }
 
    // Calculate the size of them
    for (auto& b : buffers)
        size +=  b.getView().data.getBytesNeeded (b.getSize());
 
    // Then put them back in the fifo
    for (auto& b : buffers)
        fifo->push (std::move (b));
 
    return size;
}
 
}} // namespace tracktion