buffer.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cstddef>
#include <cstdlib>
#include <limits>
#include <span>
#include <stdexcept>
#include <vector>
 
namespace pulp::audio {

template<typename SampleType = float>
class BufferView {
public:
    BufferView() = default;

    BufferView(SampleType* const* channel_ptrs, std::size_t num_channels, std::size_t num_samples)
        : channels_(channel_ptrs)
        , num_channels_(num_channels)
        , num_samples_(num_samples)
    {}

    BufferView slice(std::size_t start, std::size_t length) const {
        if (start > num_samples_) start = num_samples_;
        const auto available = num_samples_ - start;
        if (length > available) length = available;
        return BufferView(channels_, num_channels_, length, sample_offset_ + start);
    }

    std::span<SampleType> channel(std::size_t index) {
        return {channels_[index] + sample_offset_, num_samples_};
    }

    std::span<const SampleType> channel(std::size_t index) const {
        return {channels_[index] + sample_offset_, num_samples_};
    }

    SampleType* channel_ptr(std::size_t index) { return channels_[index] + sample_offset_; }
    const SampleType* channel_ptr(std::size_t index) const { return channels_[index] + sample_offset_; }

    bool has_valid_channels() const noexcept {
        if (num_channels_ != 0 && channels_ == nullptr)
            return false;
        for (std::size_t channel = 0; channel < num_channels_; ++channel)
            if (channels_[channel] == nullptr)
                return false;
        return true;
    }
 
    std::size_t num_channels() const { return num_channels_; }
    std::size_t num_samples() const { return num_samples_; }

    bool empty() const { return num_channels_ == 0 || num_samples_ == 0; }

    void clear() {
        for (std::size_t ch = 0; ch < num_channels_; ++ch) {
            std::fill_n(channels_[ch] + sample_offset_, num_samples_, SampleType{0});
        }
    }
 
private:
    BufferView(SampleType* const* channel_ptrs, std::size_t num_channels,
               std::size_t num_samples, std::size_t sample_offset)
        : channels_(channel_ptrs)
        , num_channels_(num_channels)
        , num_samples_(num_samples)
        , sample_offset_(sample_offset)
    {}
 
    SampleType* const* channels_ = nullptr;
    std::size_t num_channels_ = 0;
    std::size_t num_samples_ = 0;
    std::size_t sample_offset_ = 0;
};

template<typename SampleType = float>
class Buffer {
public:
    Buffer() = default;

    Buffer(std::size_t num_channels, std::size_t num_samples)
    {
        resize(num_channels, num_samples);
    }
 
    Buffer(const Buffer& other)
        : data_(other.data_)
        , num_channels_(other.num_channels_)
        , num_samples_(other.num_samples_) {
        refresh_channel_pointers();
    }
 
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            data_ = other.data_;
            num_channels_ = other.num_channels_;
            num_samples_ = other.num_samples_;
            refresh_channel_pointers();
        }
        return *this;
    }
 
    Buffer(Buffer&& other)
        : data_(std::move(other.data_))
        , num_channels_(other.num_channels_)
        , num_samples_(other.num_samples_) {
        refresh_channel_pointers();
        other.num_channels_ = 0;
        other.num_samples_ = 0;
        other.ptrs_.clear();
    }
 
    Buffer& operator=(Buffer&& other) {
        if (this != &other) {
            data_ = std::move(other.data_);
            num_channels_ = other.num_channels_;
            num_samples_ = other.num_samples_;
            refresh_channel_pointers();
            other.num_channels_ = 0;
            other.num_samples_ = 0;
            other.ptrs_.clear();
        }
        return *this;
    }

    void resize(std::size_t num_channels, std::size_t num_samples) {
        const auto sample_count = checked_sample_count(num_channels, num_samples);
        num_channels_ = num_channels;
        num_samples_ = num_samples;
        data_.resize(sample_count, SampleType{0});
        refresh_channel_pointers();
    }

    BufferView<SampleType> view() {
        return {ptrs_.data(), num_channels_, num_samples_};
    }

    BufferView<const SampleType> view() const {
        return {ptrs_.data(), num_channels_, num_samples_};
    }

    std::span<SampleType> channel(std::size_t index) {
        return {ptrs_[index], num_samples_};
    }

    std::span<const SampleType> channel(std::size_t index) const {
        return {ptrs_[index], num_samples_};
    }
 
    std::size_t num_channels() const { return num_channels_; }
    std::size_t num_samples() const { return num_samples_; }
    std::size_t allocated_sample_capacity() const noexcept { return data_.capacity(); }

    void release() noexcept {
        std::vector<SampleType>().swap(data_);
        std::vector<SampleType*>().swap(ptrs_);
        num_channels_ = 0;
        num_samples_ = 0;
    }

    void clear() {
        std::fill(data_.begin(), data_.end(), SampleType{0});
    }
 
private:
    static std::size_t checked_sample_count(std::size_t num_channels,
                                            std::size_t num_samples) {
        if (num_channels != 0 &&
            num_samples > std::numeric_limits<std::size_t>::max() / num_channels) {
#if defined(__cpp_exceptions) && __cpp_exceptions
            throw std::length_error("audio buffer dimensions overflow");
#else
            // No C++ exception runtime (e.g. wasi-sdk libc++ built without EH).
            // An overflow here is a programming error, not a recoverable input.
            std::abort();
#endif
        }
        return num_channels * num_samples;
    }
 
    void refresh_channel_pointers() {
        ptrs_.resize(num_channels_);
        for (std::size_t ch = 0; ch < num_channels_; ++ch) {
            ptrs_[ch] = data_.data() + ch * num_samples_;
        }
    }
 
    std::vector<SampleType> data_;
    std::vector<SampleType*> ptrs_;
    std::size_t num_channels_ = 0;
    std::size_t num_samples_ = 0;
};
 
} // namespace pulp::audio