Struct MidiSequencer 

pub struct MidiSequencer {
    pub file: Arc<MidiFile>,
    pub time: f64,
    pub index: usize,
    pub loop_point: Option<(f64, usize)>,
    pub loop_play: bool,
    pub paused: bool,
    pub finished: bool,
    held: Vec<(u8, u8)>,
    silent: bool,
}

One sequence, its clock and where it loops.

The gameplay world owns it as a component and advances it once a frame, so playback state is ordinary data in the world that asks for it: pausing is a field. Nothing here touches the audio thread; MidiSequencer::advance sends it midi_jobs.

The voice a sequence plays into is shared with every other sequence in the scene, so anything that cuts a pass short — a rewind, a pause, a loop back to the marker — releases the notes this sequence pressed and leaves the rest alone, instead of letting them ring into the next pass.

Fields

file: Arc<MidiFile>

The sequence being played.

time: f64

Seconds since the sequence started.

index: usize

The index of the next event to send.

loop_point: Option<(f64, usize)>

Where the sequence returns to once it reaches its end: seconds and event index, from the file’s loop marker. None until a marker is reached, in which case the sequence repeats from its start.

Written by hand, it loops a passage the file never marked; see MidiSequencer::advance.

loop_play: bool

Whether reaching the end returns to the loop point instead of stopping.

paused: bool

Whether the clock stands still.

finished: bool

Whether the sequence reached its end and stayed there.

held: Vec<(u8, u8)>

The notes this sequence pressed and has not released, by channel and key. A shared voice is why the exact notes are remembered rather than silenced wholesale: an all-notes-off would cut another sequence’s music too.

silent: bool

Whether the next advance has to release those notes before it plays anything, because a rewind cut a pass short since the last one.

Implementations

impl MidiSequencer

pub fn new(file: Arc<MidiFile>) -> Self

Starts file from its beginning, playing once.

pub fn rewind(&mut self)

Puts the sequence back at its start, playing.

loop_point is left alone, because a hand-written one has no marker to be restored from. The notes the pass left sounding are released on the next MidiSequencer::advance: a rewind has no sender to reach the voice with, and they must not ring into the new pass.

pub fn advance(&mut self, delta: f64, voice: Entity, audio: &JobSender)

Sends every event that came due in the last delta seconds to voice, and loops or stops when the sequence runs out.

A message’s delay keeps its distance from the start of the frame, so events due within one frame still reach the synthesizer in order and at their own offsets. The audio thread can only place them within the fill it renders, so an event lands closer to its moment than one frame but not exactly on it.

The voice is shared with every other sequence in the scene, so a note held across the end of a pass would ring into the next one, and a note held when the clock stops would ring through the pause. Reaching the end, looping, pausing and rewinding all release the notes this sequence pressed, and leave the other sequences’ notes sounding.

fn due(&self) -> Option<(f64, MidiMessage)>

The event at the cursor, once the clock has reached it.

Read through a borrow that ends with the call, so the advance is free to change the sequence between two events.

fn pressed(&mut self, kind: MidiEventKind)

Records what kind does to the notes this sequence holds sounding.

fn release(&mut self, voice: Entity, audio: &JobSender)

Releases the notes this sequence pressed, and only those: the voice is shared, and an all-notes-off would cut another sequence’s music.