AudioSampleBuffer.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the Water library.
   Copyright (c) 2016 ROLI Ltd.
   Copyright (C) 2017-2022 Filipe Coelho <falktx@falktx.com>
 
   Permission is granted to use this software under the terms of the ISC license
   http://www.isc.org/downloads/software-support-policy/isc-license/
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
   copyright notice and this permission notice appear in all copies.
 
   THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD
   TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
   OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
   USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
   TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
   OF THIS SOFTWARE.
 
  ==============================================================================
*/
 
#ifndef WATER_AUDIOSAMPLEBUFFER_H_INCLUDED
#define WATER_AUDIOSAMPLEBUFFER_H_INCLUDED
 
#include "../memory/HeapBlock.h"
 
#include "CarlaMathUtils.hpp"
 
namespace water {
 
//==============================================================================
class AudioSampleBuffer
{
public:
    //==============================================================================
    AudioSampleBuffer() noexcept
       : numChannels(0),
         size(0),
         allocatedBytes(0),
         channels(static_cast<float**> (preallocatedChannelSpace)),
         allocatedData(),
         isClear(false)
    {
    }
 
    //==============================================================================
    AudioSampleBuffer (const uint32_t numChannelsToAllocate,
                       const uint32_t numSamplesToAllocate,
                       const bool clearData = false) noexcept
       : numChannels(numChannelsToAllocate),
         size(numSamplesToAllocate),
         allocatedBytes(0),
         channels(nullptr),
         allocatedData(),
         isClear(false)
    {
        allocateData (clearData);
    }

    AudioSampleBuffer (float* const* dataToReferTo,
                       const uint32_t numChannelsToUse,
                       const uint32_t numSamples) noexcept
        : numChannels(numChannelsToUse),
          size(numSamples),
          allocatedBytes(0),
          channels(nullptr),
          allocatedData(),
          isClear(false)
    {
        CARLA_SAFE_ASSERT_RETURN (dataToReferTo != nullptr,);
 
        allocateChannels (dataToReferTo, 0);
    }

    AudioSampleBuffer (float* const* dataToReferTo,
                       const uint32_t numChannelsToUse,
                       const uint32_t startSample,
                       const uint32_t numSamples) noexcept
        : numChannels(numChannelsToUse),
          size(numSamples),
          allocatedBytes(0),
          channels(nullptr),
          allocatedData(),
          isClear(false)
    {
        CARLA_SAFE_ASSERT_RETURN (dataToReferTo != nullptr,);
 
        allocateChannels (dataToReferTo, startSample);
    }

    AudioSampleBuffer (const AudioSampleBuffer& other) noexcept
       : numChannels(other.numChannels),
         size(other.size),
         allocatedBytes(other.allocatedBytes),
         channels(nullptr),
         allocatedData(),
         isClear(false)
    {
        if (allocatedBytes == 0)
        {
            allocateChannels (other.channels, 0);
        }
        else
        {
            allocateData();
 
            if (other.isClear)
            {
                clear();
            }
            else
            {
                for (uint32_t i = 0; i < numChannels; ++i)
                    carla_copyFloats (channels[i], other.channels[i], size);
            }
        }
    }
 
    AudioSampleBuffer& operator= (const AudioSampleBuffer& other) noexcept
    {
        numChannels = other.numChannels;
        size = other.size;
        allocatedBytes = other.allocatedBytes;
        channels = other.channels;
 
        if (allocatedBytes == 0)
        {
            allocateChannels (other.channels, 0);
        }
        else
        {
            allocateData();
 
            if (other.isClear)
            {
                clear();
            }
            else
            {
                for (uint32_t i = 0; i < numChannels; ++i)
                    carla_copyFloats (channels[i], other.channels[i], size);
            }
        }
        return *this;
    }

    ~AudioSampleBuffer() noexcept {}
 
    //==============================================================================
    uint32_t getNumChannels() const noexcept                             { return numChannels; }

    uint32_t getNumSamples() const noexcept                              { return size; }

    const float* getReadPointer (const uint32_t channelNumber) const noexcept
    {
        CARLA_SAFE_ASSERT_RETURN (channelNumber < numChannels, nullptr);
 
        return channels [channelNumber];
    }

    const float* getReadPointer (const uint32_t channelNumber, const uint32_t sampleIndex) const noexcept
    {
        CARLA_SAFE_ASSERT_RETURN (channelNumber < numChannels, nullptr);
        CARLA_SAFE_ASSERT_RETURN (sampleIndex < size, nullptr);
 
        return channels [channelNumber] + sampleIndex;
    }

    float* getWritePointer (const uint32_t channelNumber) noexcept
    {
        CARLA_SAFE_ASSERT_RETURN (channelNumber < numChannels, nullptr);
 
        isClear = false;
        return channels [channelNumber];
    }

    float* getWritePointer (const uint32_t channelNumber, const uint32_t sampleIndex) noexcept
    {
        CARLA_SAFE_ASSERT_RETURN (channelNumber < numChannels, nullptr);
        CARLA_SAFE_ASSERT_RETURN (sampleIndex < size, nullptr);
 
        isClear = false;
        return channels [channelNumber] + sampleIndex;
    }

    const float** getArrayOfReadPointers() const noexcept            { return const_cast<const float**> (channels); }

    float** getArrayOfWritePointers() noexcept                       { isClear = false; return channels; }
 
    //==============================================================================
    bool setSize (const uint32_t newNumChannels, const uint32_t newNumSamples) noexcept
    {
        if (newNumSamples != size || newNumChannels != numChannels)
        {
            const uint32_t allocatedSamplesPerChannel = (newNumSamples + 3) & ~3u;
            const uint32_t channelListSize = ((sizeof (float*) * (newNumChannels + 1)) + 15) & ~15u;
            const size_t newTotalBytes = newNumChannels * allocatedSamplesPerChannel * sizeof(float) + channelListSize + 32u;
 
            if (allocatedBytes >= newTotalBytes)
            {
                if (isClear)
                    allocatedData.clear (newTotalBytes);
            }
            else
            {
                CARLA_SAFE_ASSERT_RETURN (allocatedData.allocate (newTotalBytes, isClear), false);
                allocatedBytes = newTotalBytes;
                channels = reinterpret_cast<float**> (allocatedData.getData());
            }
 
            float* chan = reinterpret_cast<float*> (allocatedData + channelListSize);
            for (uint32_t i = 0; i < newNumChannels; ++i)
            {
                channels[i] = chan;
                chan += allocatedSamplesPerChannel;
            }
 
            channels [newNumChannels] = nullptr;
            size = newNumSamples;
            numChannels = newNumChannels;
        }
 
        return true;
    }
 
    //==============================================================================
    bool setSizeRT (const uint32_t newNumSamples) noexcept
    {
        if (newNumSamples != size)
        {
            const uint32_t allocatedSamplesPerChannel = (newNumSamples + 3) & ~3u;
            const uint32_t channelListSize = ((sizeof (float*) * (numChannels + 1)) + 15) & ~15u;
            const size_t newTotalBytes = numChannels * allocatedSamplesPerChannel * sizeof(float) + channelListSize + 32u;
 
            CARLA_SAFE_ASSERT_RETURN(allocatedBytes >= newTotalBytes, false);
 
            float* chan = reinterpret_cast<float*> (allocatedData + channelListSize);
            for (uint32_t i = 0; i < numChannels; ++i)
            {
                channels[i] = chan;
                chan += allocatedSamplesPerChannel;
            }
 
            size = newNumSamples;
        }
 
        return true;
    }

    bool setDataToReferTo (float** dataToReferTo,
                           const uint32_t newNumChannels,
                           const uint32_t newNumSamples) noexcept
    {
        CARLA_SAFE_ASSERT_RETURN(dataToReferTo != nullptr, false);
 
        if (allocatedBytes != 0)
        {
            allocatedBytes = 0;
            allocatedData.free();
        }
 
        numChannels = newNumChannels;
        size = newNumSamples;
 
        return allocateChannels (dataToReferTo, 0);
    }
 
    //==============================================================================
    void clear() noexcept
    {
        if (! isClear)
        {
            for (uint32_t i = 0; i < numChannels; ++i)
                carla_zeroFloats (channels[i], size);
 
            isClear = true;
        }
    }

    void clear (const uint32_t startSample,
                const uint32_t numSamples) noexcept
    {
        CARLA_SAFE_ASSERT_UINT2_RETURN(startSample + numSamples <= size, numSamples, size,);
 
        if (! isClear)
        {
            if (startSample == 0 && numSamples == size)
                isClear = true;
 
            for (uint32_t i = 0; i < numChannels; ++i)
                carla_zeroFloats (channels[i] + startSample, numSamples);
        }
    }

    void clear (const uint32_t channel,
                const uint32_t startSample,
                const uint32_t numSamples) noexcept
    {
        CARLA_SAFE_ASSERT_UINT2_RETURN(channel < numChannels, channel, numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(startSample + numSamples <= size, numSamples, size,);
 
        if (! isClear)
            carla_zeroFloats (channels [channel] + startSample, numSamples);
    }

    bool hasBeenCleared() const noexcept                            { return isClear; }
 
    //==============================================================================
    void addFrom (const uint32_t destChannel,
                  const uint32_t destStartSample,
                  const AudioSampleBuffer& source,
                  const uint32_t sourceChannel,
                  const uint32_t sourceStartSample,
                  const uint32_t numSamples,
                  const float gainToApplyToSource = 1.0f) noexcept
    {
        CARLA_SAFE_ASSERT_UINT2_RETURN(&source != this || sourceChannel != destChannel, sourceChannel, destChannel,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(destChannel < numChannels, destChannel, numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(sourceChannel < source.numChannels, sourceChannel, source.numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(destStartSample + numSamples <= size, numSamples, size,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(sourceStartSample + numSamples <= source.size, numSamples, source.size,);
 
        if (carla_isNotZero(gainToApplyToSource) && numSamples != 0 && ! source.isClear)
        {
            float* const d = channels [destChannel] + destStartSample;
            const float* const s  = source.channels [sourceChannel] + sourceStartSample;
 
            if (isClear)
            {
                isClear = false;
 
                if (carla_isNotZero(gainToApplyToSource - 1.0f))
                    carla_copyWithMultiply (d, s, gainToApplyToSource, numSamples);
                else
                    carla_copyFloats (d, s, numSamples);
            }
            else
            {
                if (carla_isNotZero(gainToApplyToSource - 1.0f))
                    carla_addWithMultiply (d, s, gainToApplyToSource, numSamples);
                else
                    carla_add (d, s, numSamples);
            }
        }
    }
 

    void addFrom (const uint32_t destChannel,
                  const uint32_t destStartSample,
                  const float* source,
                  const uint32_t numSamples,
                  float gainToApplyToSource = 1.0f) noexcept
    {
        CARLA_SAFE_ASSERT_UINT2_RETURN(destChannel < numChannels, destChannel, numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(destStartSample + numSamples <= size, numSamples, size,);
        CARLA_SAFE_ASSERT_RETURN(source != nullptr,);
 
        if (carla_isNotZero(gainToApplyToSource) && numSamples != 0)
        {
            float* const d = channels [destChannel] + destStartSample;
 
            if (isClear)
            {
                isClear = false;
 
                if (carla_isNotZero(gainToApplyToSource - 1.0f))
                    carla_copyWithMultiply (d, source, gainToApplyToSource, numSamples);
                else
                    carla_copyFloats (d, source, numSamples);
            }
            else
            {
                if (carla_isNotZero(gainToApplyToSource - 1.0f))
                    carla_addWithMultiply (d, source, gainToApplyToSource, numSamples);
                else
                    carla_add (d, source, numSamples);
            }
        }
    }

    void copyFrom (const uint32_t destChannel,
                   const uint32_t destStartSample,
                   const AudioSampleBuffer& source,
                   const uint32_t sourceChannel,
                   const uint32_t sourceStartSample,
                   const uint32_t numSamples) noexcept
    {
        CARLA_SAFE_ASSERT_UINT2_RETURN(&source != this || sourceChannel != destChannel, sourceChannel, destChannel,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(destChannel < numChannels, destChannel, numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(sourceChannel < source.numChannels, sourceChannel, source.numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(destStartSample + numSamples <= size, numSamples, size,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(sourceStartSample + numSamples <= source.size, numSamples, source.size,);
 
        if (numSamples > 0)
        {
            if (source.isClear)
            {
                if (! isClear)
                    carla_zeroFloats (channels [destChannel] + destStartSample, numSamples);
            }
            else
            {
                isClear = false;
                carla_copyFloats (channels [destChannel] + destStartSample,
                                             source.channels [sourceChannel] + sourceStartSample,
                                             numSamples);
            }
        }
    }

    void copyFrom (const uint32_t destChannel,
                   const uint32_t destStartSample,
                   const float* source,
                   const uint32_t numSamples) noexcept
    {
        CARLA_SAFE_ASSERT_UINT2_RETURN(destChannel < numChannels, destChannel, numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(destStartSample + numSamples <= size, numSamples, size,);
        CARLA_SAFE_ASSERT_RETURN(source != nullptr,);
 
        if (numSamples > 0)
        {
            isClear = false;
            carla_copyFloats (channels [destChannel] + destStartSample, source, numSamples);
        }
    }

    void copyFrom (const uint32_t destChannel,
                   const uint32_t destStartSample,
                   const float* source,
                   const uint32_t numSamples,
                   float gain) noexcept
    {
        CARLA_SAFE_ASSERT_UINT2_RETURN(destChannel < numChannels, destChannel, numChannels,);
        CARLA_SAFE_ASSERT_UINT2_RETURN(destStartSample + numSamples <= size, numSamples, size,);
        CARLA_SAFE_ASSERT_RETURN(source != nullptr,);
 
        if (numSamples > 0)
        {
            float* const d = channels [destChannel] + destStartSample;
 
            if (carla_isZero(gain))
            {
                if (! isClear)
                    carla_zeroFloats (d, numSamples);
            }
            else if (carla_isZero(gain - 1.0f))
            {
                isClear = false;
                carla_copyFloats (d, source, numSamples);
            }
            else
            {
                isClear = false;
                carla_copyWithMultiply (d, source, gain, numSamples);
            }
        }
    }

    void copyFromInterleavedSource (const uint32_t destChannel,
                                    const float* source,
                                    const uint32_t totalNumSamples) noexcept
    {
        CARLA_SAFE_ASSERT_RETURN(destChannel < numChannels,);
        CARLA_SAFE_ASSERT_RETURN(source != nullptr,);
 
        if (const uint32_t numSamples = totalNumSamples / numChannels)
        {
            CARLA_SAFE_ASSERT_RETURN(numSamples <= size,);
 
            isClear = false;
            float* d = channels [destChannel];
 
            for (uint32_t i=0; i < numSamples; ++i)
                d[i] = source[i * numChannels + destChannel];
        }
    }
 
private:
    //==============================================================================
    uint32_t numChannels, size;
    size_t allocatedBytes;
    float** channels;
    HeapBlock<char> allocatedData;
    float* preallocatedChannelSpace [32];
    bool isClear;
 
    bool allocateData (bool clearData = false)
    {
        const size_t channelListSize = sizeof (float*) * (numChannels + 1);
        const size_t nextAllocatedBytes = numChannels * size * sizeof (float) + channelListSize + 32;
        CARLA_SAFE_ASSERT_RETURN (allocatedData.allocate (nextAllocatedBytes, clearData), false);
 
        allocatedBytes = nextAllocatedBytes;
        channels = reinterpret_cast<float**> (allocatedData.getData());
 
        float* chan = (float*) (allocatedData + channelListSize);
        for (uint32_t i = 0; i < numChannels; ++i)
        {
            channels[i] = chan;
            chan += size;
        }
 
        channels [numChannels] = nullptr;
        isClear = clearData;
        return true;
    }
 
    bool allocateChannels (float* const* const dataToReferTo, const uint32_t offset)
    {
        // (try to avoid doing a malloc here, as that'll blow up things like Pro-Tools)
        if (numChannels < numElementsInArray (preallocatedChannelSpace))
        {
            channels = static_cast<float**> (preallocatedChannelSpace);
        }
        else
        {
            CARLA_SAFE_ASSERT_RETURN( allocatedData.malloc (numChannels + 1, sizeof (float*)), false);
            channels = reinterpret_cast<float**> (allocatedData.getData());
        }
 
        for (uint32_t i = 0; i < numChannels; ++i)
        {
            // you have to pass in the same number of valid pointers as numChannels
            CARLA_SAFE_ASSERT_CONTINUE (dataToReferTo[i] != nullptr);
 
            channels[i] = dataToReferTo[i] + offset;
        }
 
        channels [numChannels] = nullptr;
        isClear = false;
        return true;
    }
 
    // CARLA_DECLARE_NON_COPYABLE(AudioSampleBuffer)
};
 
}
 
#endif // WATER_AUDIOSAMPLEBUFFER_H_INCLUDED