Struct ClockTick 

pub struct ClockTick {
    pub sample_pos: u64,
    pub samples_since_last: u32,
    pub is_new_block: bool,
    pub sample_rate: f32,
    pub tempo: Option<f32>,
    pub source: String,
    pub speed_ratio: f64,
    pub is_final: bool,
    pub io_quantum: u32,
}

A tick of the system clock

Sent to nodes on every signal block to provide timing information and synchronize processing. This is the fundamental timing primitive in Rill.

Fields

• sample_pos - Absolute sample position since start
• samples_since_last - Number of samples since the last tick
• is_new_block - Whether this is the start of a new block
• sample_rate - Current sample rate in Hz
• tempo - Current tempo in BPM (if available)
• source - Which backend produced this tick (e.g. “alsa:default”)

I/O access is handled directly through IoCapture and IoPlayback traits — the tick carries only timing metadata.

Example

use rill_core::time::ClockTick;

let tick = ClockTick::new(44100, 64, 44100.0, "test".into());
assert_eq!(tick.absolute_seconds(), 1.0);
assert_eq!(tick.delta_seconds(), 64.0 / 44100.0);

Fields

sample_pos: u64

Absolute sample position since start

samples_since_last: u32

Number of samples since the last tick

is_new_block: bool

Whether this is the start of a new block

sample_rate: f32

Current sample rate in Hz

tempo: Option<f32>

Current tempo in BPM (if available)

source: String

Which backend produced this tick (e.g. “alsa:default”, “pipewire:0”).

speed_ratio: f64

Hardware clock correction factor: configured_rate / actual_rate.

1.0 = nominal (rates match). < 1.0 = hardware runs faster. > 1.0 = hardware runs slower. Set by the backend when the negotiated hardware rate differs from the graph’s configured rate.

is_final: bool

Whether this tick should trigger a ClockTick dispatch to modules.

true by default. Chunking backends (PipeWire) set this to false for intermediate chunks and true only for the final chunk of the DMA buffer — avoiding 48 ClockTick dispatches per PW callback.

io_quantum: u32

Number of frames the I/O backend processes per callback (its quantum).

The graph processes one block_size chunk per pass, but a backend may batch many chunks into a single I/O callback (e.g. PipeWire delivers a 12288-frame buffer = 48 × 256 chunks). Tick-driven control producers (sequencers/servos) that run asynchronously only see the results of a callback after it returns, so a change reacting to a tick in the current callback can only be rendered in the next one. Producers use io_quantum as the sample look-ahead when stamping SetParameter::sample_pos so the change lands on the correct block of the next callback instead of collapsing onto block 0. Defaults to samples_since_last (one chunk per callback).

Implementations

impl ClockTick

pub fn new( sample_pos: u64, samples_since_last: u32, sample_rate: f32, source: String, ) -> Self

Create a new clock tick

Arguments

• sample_pos - Absolute sample position
• samples_since_last - Samples since last tick
• sample_rate - Sample rate in Hz
• source - Backend source name

Returns

A new ClockTick with is_new_block = true and tempo = None

pub fn with_tempo( sample_pos: u64, samples_since_last: u32, sample_rate: f32, tempo: f32, source: String, ) -> Self

Create a new clock tick with tempo information

Arguments

• sample_pos - Absolute sample position
• samples_since_last - Samples since last tick
• sample_rate - Sample rate in Hz
• tempo - Tempo in BPM
• source - Backend source name

pub fn with_io_quantum(self, io_quantum: u32) -> Self

Set the I/O backend’s per-callback quantum (frames processed per callback).

Backends that batch multiple block_size chunks into one callback set this so asynchronous control producers know how far ahead to schedule sample-accurate parameter changes. See io_quantum.

pub fn delta_seconds(&self) -> f32

Get the time since the last tick in seconds

Returns

Time in seconds since the previous tick

pub fn absolute_seconds(&self) -> f64

Get the absolute time in seconds since start

Returns

Absolute time in seconds

pub fn beat_position(&self) -> Option<f64>

Get the current beat position (if tempo is available)

Returns

• Some(beat) - Current beat position (fractional)
• None - No tempo information available

pub fn musical_position(&self) -> Option<(u32, u8, u8)>

Get the current bar-beat-sixteenth position (if tempo is available)

Returns

• Some((bar, beat, sixteenth)) - Musical position
• None - No tempo information available

pub fn advance(&mut self, samples: u32)

Advance to the next tick

Arguments

• samples - Number of samples to advance

pub fn is_new_bar(&self) -> bool

Check if this tick is at the start of a new bar

Returns

true if this is the first beat of a bar

pub fn is_new_beat(&self) -> bool

Check if this tick is at the start of a new beat

Returns

true if this is the start of a beat

Trait Implementations

impl Clone for ClockTick

fn clone(&self) -> ClockTick

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClockTick

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ClockTick

fn default() -> Self

Returns the “default value” for a type.

impl Display for ClockTick

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ClockTick

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.