frame_ring.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <span>
#include <utility>
#include <vector>
 
namespace ts {

class FrameRing {
public:
    explicit FrameRing(std::size_t frames);

    [[nodiscard]] std::size_t capacity() const noexcept { return capacity_; }

    [[nodiscard]] std::size_t queued() const noexcept
    {
        return static_cast<std::size_t>(write_.load(std::memory_order_relaxed)
                                        - read_.load(std::memory_order_acquire));
    }

    [[nodiscard]] std::size_t writable() const noexcept { return capacity_ - queued(); }

    void write(std::span<const float> interleaved) noexcept;

    void request_flush() noexcept { flush_.fetch_add(1, std::memory_order_release); }

    [[nodiscard]] bool flush_pending() const noexcept
    {
        return flush_.load(std::memory_order_relaxed) != ack_.load(std::memory_order_acquire);
    }

    void set_starvation_expected(bool expected) noexcept
    {
        expect_starvation_.store(expected, std::memory_order_relaxed);
    }

    std::size_t read(std::span<float> interleaved) noexcept;

    [[nodiscard]] std::int64_t underruns() const noexcept
    {
        return underruns_.load(std::memory_order_relaxed);
    }

    [[nodiscard]] std::pair<float, float> peak() const noexcept
    {
        return {peak_left_.load(std::memory_order_relaxed),
                peak_right_.load(std::memory_order_relaxed)};
    }
 
private:
    std::vector<float> samples_;
    std::size_t capacity_;
    std::size_t mask_;
 
    alignas(64) std::atomic<std::uint64_t> write_{0};
    alignas(64) std::atomic<std::uint64_t> read_{0};
 
    std::atomic<std::uint32_t> flush_{0};
    std::atomic<std::uint32_t> ack_{0};
    std::atomic<bool> expect_starvation_{false};
 
    std::atomic<std::int64_t> underruns_{0};
    std::atomic<float> peak_left_{0.0F};
    std::atomic<float> peak_right_{0.0F};
};
 
} // namespace ts