ame_AudioBuffer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <span>
 
namespace ame
{
template <class ElementType, size_t Extent>
class AudioBlockView
{
public:
    AudioBlockView (std::span<ElementType, Extent> view, const uint_fast32_t numChannels) noexcept
        : view (view),
          numChannels (numChannels),
          numSamplesPerChannel (view.size() / numChannels)
    {
    }
    ~AudioBlockView() = default;
 
    uint_fast32_t getNumChannels() const noexcept
    {
        return numChannels;
    }
 
    uint_fast32_t getNumSamplesPerChannel() const noexcept
    {
        return numSamplesPerChannel;
    }
 
    void setSample (const uint_fast32_t destChannel, const uint_fast32_t destSample, const ElementType newValue)
    {
        assert (destChannel < numChannels);
        assert (destSample < numSamplesPerChannel);
        view[destSample * numChannels + destChannel] = newValue;
    }
 
    void addSample (const uint_fast32_t destChannel, const uint_fast32_t destSample, const ElementType valueToAdd)
    {
        assert (destChannel < numChannels);
        assert (destSample < numSamplesPerChannel);
        view[destSample * numChannels + destChannel] += valueToAdd;
    }
 
    void clear()
    {
        std::fill (view.begin(), view.end(), ElementType (0.0));
    }
 
    void applyGain (const float gain)
    {
        for_each (view.begin(), view.end(), [&gain] (auto& x)
                  { x *= gain; });
    }
 
    float getPeak (const uint_fast32_t channel) const
    {
        float peak = 0.0f;
 
        for (auto i = channel; i < view.size(); i += numChannels)
        {
            const auto v = std::abs (view[i]);
            if (v > peak)
            {
                peak = v;
            }
        }
        return peak;
    }
 
    float getRMSLevel (const uint_fast32_t channel) const
    {
        assert (channel < numChannels);
        float sum = 0.0f;
        for (auto i = channel; i < view.size(); i += numChannels)
        {
            const auto sample = view[i];
            sum += sample * sample;
        }
 
        return std::sqrt (sum / numSamplesPerChannel);
    }
 
    auto subView (uint_fast32_t offset, uint_fast32_t size)
    {
        return AudioBlockView { view.subspan (offset, size), numChannels };
    }
 
    std::span<ElementType, Extent> view;
 
private:
    uint_fast32_t numChannels;
    uint_fast32_t numSamplesPerChannel;
};
 
template <typename FloatType, size_t Size>
class AudioBuffer
{
public:
    explicit AudioBuffer (const uint_fast32_t numChannels) : numChannels (numChannels), numSamplesPerChannel (Size / numChannels)
    {
    }
    ~AudioBuffer() = default;
 
    void setNumChannels (const uint_fast32_t channels)
    {
        numChannels = channels;
        numSamplesPerChannel = Size / numChannels;
    }
 
    uint_fast32_t getNumChannels() const noexcept
    {
        return numChannels;
    }
 
    uint_fast32_t getNumSamplesPerChannel() const noexcept
    {
        return numSamplesPerChannel;
    }
 
    void clear()
    {
        buffer.fill (0.0f);
    }
 
    void applyGain (const float gain)
    {
        std::for_each (buffer.begin(), buffer.end(), [&gain] (auto& e)
                       { e *= gain; });
    }
 
    auto makeAudioBlockView (uint_fast32_t offset = 0, uint_fast32_t size = Size)
    {
        std::span sp { buffer.data() + offset, size };
        return ame::AudioBlockView { sp, numChannels };
    }
 
    template <size_t Extent>
    void addFrom (const uint_fast32_t destChannel, const uint_fast32_t destStartSample, const AudioBlockView<FloatType, Extent>& source, const uint_fast32_t sourceChannel, const uint_fast32_t sourceStartSample, const uint_fast32_t numSamplesToAdd)
    {
        const auto& destOffset = destStartSample * numChannels;
        const auto& sourceOffset = sourceStartSample * source.getNumChannels();
        const auto& destEnd = destOffset + numSamplesToAdd * numChannels;
        const auto& sourceEnd = sourceOffset + numSamplesToAdd * source.getNumChannels();
 
        assert (destEnd <= Size);
        assert (sourceEnd <= source.getSize());
 
        for (uint_fast32_t i = 0; i < numSamplesToAdd; ++i)
        {
            buffer[destOffset + i * destChannel] += source.buffer[sourceOffset + i * source.getNumChannels];
        }
    }
 
    FloatType getPeak (const uint_fast32_t channel) const
    {
        assert (channel < numChannels);
        FloatType peak = 0.0;
        for (auto i = channel; i < numSamplesPerChannel * numChannels; i += numChannels)
        {
            const auto v = std::abs (buffer[i]);
            if (v > peak)
            {
                peak = v;
            }
        }
        return peak;
    }
 
    FloatType getRMSLevel (const uint_fast32_t channel) const
    {
        assert (channel < numChannels);
        FloatType sum = 0.0;
        for (auto i = channel; i < numSamplesPerChannel * numChannels; i += numChannels)
        {
            const auto sample = buffer[i];
            sum += sample * sample;
        }
 
        return static_cast<FloatType> (std::sqrt (sum / numSamplesPerChannel));
    }
 
    std::array<FloatType, Size> buffer = {};
 
private:
    uint_fast32_t numChannels;
    uint_fast32_t numSamplesPerChannel;
};
} // namespace ame