ringbuffer.hpp

Go to the documentation of this file.

#pragma once
#include <atomic>
 
#include <dsp/common.hpp>
 
 
namespace rack {
namespace dsp {
 

template <typename T, size_t S>
struct RingBuffer {
    std::atomic<size_t> start{0};
    std::atomic<size_t> end{0};
    T data[S];

    void push(T t) {
        size_t i = end % S;
        data[i] = t;
        end++;
    }

    void pushBuffer(const T* t, int n) {
        size_t i = end % S;
        size_t e1 = i + n;
        size_t e2 = (e1 < S) ? e1 : S;
        std::memcpy(&data[i], t, sizeof(T) * (e2 - i));
        if (e1 > S) {
            std::memcpy(data, &t[S - i], sizeof(T) * (e1 - S));
        }
        end += n;
    }

    T shift() {
        size_t i = start % S;
        T t = data[i];
        start++;
        return t;
    }

    void shiftBuffer(T* t, size_t n) {
        size_t i = start % S;
        size_t s1 = i + n;
        size_t s2 = (s1 < S) ? s1 : S;
        std::memcpy(t, &data[i], sizeof(T) * (s2 - i));
        if (s1 > S) {
            std::memcpy(&t[S - i], data, sizeof(T) * (s1 - S));
        }
        start += n;
    }
    void clear() {
        start = end.load();
    }
    bool empty() const {
        return start >= end;
    }
    bool full() const {
        return end - start >= S;
    }
    size_t size() const {
        return end - start;
    }
    size_t capacity() const {
        return S - size();
    }
};

template <typename T, size_t S>
struct DoubleRingBuffer {
    std::atomic<size_t> start{0};
    std::atomic<size_t> end{0};
    T data[2 * S];
 
    void push(T t) {
        size_t i = end % S;
        data[i] = t;
        data[i + S] = t;
        end++;
    }
    T shift() {
        size_t i = start % S;
        T t = data[i];
        start++;
        return t;
    }
    void clear() {
        start = end.load();
    }
    bool empty() const {
        return start >= end;
    }
    bool full() const {
        return end - start >= S;
    }
    size_t size() const {
        return end - start;
    }
    size_t capacity() const {
        return S - size();
    }

    T* endData() {
        size_t i = end % S;
        return &data[i];
    }
    void endIncr(size_t n) {
        size_t i = end % S;
        size_t e1 = i + n;
        size_t e2 = (e1 < S) ? e1 : S;
        // Copy data forward
        std::memcpy(&data[S + i], &data[i], sizeof(T) * (e2 - i));
 
        if (e1 > S) {
            // Copy data backward from the doubled block to the main block
            std::memcpy(data, &data[S], sizeof(T) * (e1 - S));
        }
        end += n;
    }

    const T* startData() const {
        size_t i = start % S;
        return &data[i];
    }
    void startIncr(size_t n) {
        start += n;
    }
};

template <typename T, size_t S, size_t N>
struct AppleRingBuffer {
    size_t start = 0;
    size_t end = 0;
    T data[N];
 
    void returnBuffer() {
        // move end block to beginning
        // may overlap, but memmove handles that correctly
        size_t s = size();
        std::memmove(data, &data[start], sizeof(T) * s);
        start = 0;
        end = s;
    }
    void push(T t) {
        if (end + 1 > N) {
            returnBuffer();
        }
        data[end++] = t;
    }
    T shift() {
        return data[start++];
    }
    bool empty() const {
        return start == end;
    }
    bool full() const {
        return end - start == S;
    }
    size_t size() const {
        return end - start;
    }
    size_t capacity() const {
        return S - size();
    }

    T* endData(size_t n) {
        if (end + n > N) {
            returnBuffer();
        }
        return &data[end];
    }

    void endIncr(size_t n) {
        end += n;
    }

    const T* startData() const {
        return &data[start];
    }
    void startIncr(size_t n) {
        // This is valid as long as n < S
        start += n;
    }
};
 
 
} // namespace dsp
} // namespace rack