pull_rate_detector.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <chrono>
#include <cstddef>
 
namespace pulp::audio {

class PullRateDetector {
  public:
    using Clock = std::chrono::steady_clock;
    static constexpr std::size_t kWindow = 8;
    static constexpr double kEnter = 2.0;
    static constexpr double kLeave = 1.25;

    bool observe(std::size_t frames, double sample_rate, Clock::time_point now) noexcept {
        calls_[next_ % kWindow] = {now, frames};
        ++next_;
        if (next_ < kWindow || !(sample_rate > 0.0))
            return fast_;
        // The oldest call in the window starts the wall-clock span; the audio
        // of the newer calls is what was delivered within that span.
        const auto& oldest = calls_[next_ % kWindow];
        std::size_t newer_frames = 0;
        for (std::size_t i = 1; i < kWindow; ++i)
            newer_frames += calls_[(next_ + i) % kWindow].frames;
        const double audio_s = static_cast<double>(newer_frames) / sample_rate;
        const double wall_s = std::chrono::duration<double>(now - oldest.time).count();
        speed_ = wall_s > 0.0 ? audio_s / wall_s : kEnter * 1000.0;
        fast_ = fast_ ? speed_ >= kLeave : speed_ > kEnter;
        return fast_;
    }
 
    bool fast() const noexcept {
        return fast_;
    }

    double speed() const noexcept {
        return speed_;
    }

    void reset() noexcept {
        next_ = 0;
        fast_ = false;
        speed_ = 0.0;
    }
 
  private:
    struct Call {
        Clock::time_point time{};
        std::size_t frames = 0;
    };
    std::array<Call, kWindow> calls_{};
    std::size_t next_ = 0;
    bool fast_ = false;
    double speed_ = 0.0;
};
 
} // namespace pulp::audio