sample_clock.hpp

Go to the documentation of this file.

/**
 * @file sample_clock.hpp
 * @brief Audio-clock frame counter — the elapsed-samples source for control code
 * @ingroup hal
 *
 * Counts stereo frames the audio driver has handed to the codec since boot.
 * The count advances only with the audio clock, so control code that needs
 * elapsed time (the FDP-073 scheduler's `tick(elapsed_samples)`) reads it
 * instead of assuming a timer rate: the 1 kHz control timer is not
 * sample-locked to the codec.
 *
 * One writer: the audio driver calls advance() once per block, after the
 * application callback returns. Any context may call now(). Consumers take
 * unsigned deltas, which stay correct across the wrap every 2^32 frames
 * (~24.8 h at 48 kHz).
 *
 * The counter is a relaxed atomic: race-free between the audio thread and
 * the control thread on the workbench, plain LDR/STR on Cortex-M7. It
 * publishes no other data, so no ordering is needed.
 */
 
#ifndef SBL_HW_HAL_AUDIO_SAMPLE_CLOCK_HPP_
#define SBL_HW_HAL_AUDIO_SAMPLE_CLOCK_HPP_
 
#include <atomic>
#include <cstdint>
 
namespace sbl {
namespace hal {
namespace audio {
 
class SampleClock {
public:
    /// Frames clocked out since boot (wraps; take unsigned deltas).
    static uint32_t now() {
        return frames_.load(std::memory_order_relaxed);
    }
 
    /// Add one block's frames. Audio driver only — single writer, so a
    /// load/store pair replaces a read-modify-write (no LDREX/STREX).
    static void advance(uint32_t frames) {
        frames_.store(frames_.load(std::memory_order_relaxed) + frames,
                      std::memory_order_relaxed);
    }
 
private:
    static_assert(std::atomic<uint32_t>::is_always_lock_free,
                  "SampleClock needs a lock-free 32-bit atomic");
 
    static inline std::atomic<uint32_t> frames_{0};
};
 
} // namespace audio
} // namespace hal
} // namespace sbl
 
#endif // SBL_HW_HAL_AUDIO_SAMPLE_CLOCK_HPP_