refactor into fewer crates, pt.2

crates/device/src/sequencer/seq_clip.rs

@@ -0,0 +1,114 @@
+//! MIDI clip data.
+use crate::*;
+
+pub trait HasMidiClip {
+    fn clip (&self) -> Option<Arc<RwLock<MidiClip>>>;
+}
+
+#[macro_export] macro_rules! has_clip {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasMidiClip for $Struct $(<$($L),*$($T),*>)? {
+            fn clip (&$self) -> Option<Arc<RwLock<MidiClip>>> { $cb }
+        }
+    }
+}
+
+/// A MIDI sequence.
+#[derive(Debug, Clone, Default)]
+pub struct MidiClip {
+    pub uuid:        uuid::Uuid,
+    /// Name of clip
+    pub name:        Arc<str>,
+    /// Temporal resolution in pulses per quarter note
+    pub ppq:         usize,
+    /// Length of clip in pulses
+    pub length:      usize,
+    /// Notes in clip
+    pub notes:       MidiData,
+    /// Whether to loop the clip or play it once
+    pub looped:      bool,
+    /// Start of loop
+    pub loop_start:  usize,
+    /// Length of loop
+    pub loop_length: usize,
+    /// All notes are displayed with minimum length
+    pub percussive:  bool,
+    /// Identifying color of clip
+    pub color:       ItemTheme,
+}
+
+/// MIDI message structural
+pub type MidiData = Vec<Vec<MidiMessage>>;
+
+impl MidiClip {
+    pub fn new (
+        name:    impl AsRef<str>,
+        looped:  bool,
+        length:  usize,
+        notes:   Option<MidiData>,
+        color:   Option<ItemTheme>,
+    ) -> Self {
+        Self {
+            uuid:        uuid::Uuid::new_v4(),
+            name:        name.as_ref().into(),
+            ppq:         PPQ,
+            length,
+            notes:       notes.unwrap_or(vec![Vec::with_capacity(16);length]),
+            looped,
+            loop_start:  0,
+            loop_length: length,
+            percussive:  true,
+            color:       color.unwrap_or_else(ItemTheme::random)
+        }
+    }
+    pub fn count_midi_messages (&self) -> usize {
+        let mut count = 0;
+        for tick in self.notes.iter() {
+            count += tick.len();
+        }
+        count
+    }
+    pub fn set_length (&mut self, length: usize) {
+        self.length = length;
+        self.notes  = vec![Vec::with_capacity(16);length];
+    }
+    pub fn duplicate (&self) -> Self {
+        let mut clone = self.clone();
+        clone.uuid = uuid::Uuid::new_v4();
+        clone
+    }
+    pub fn toggle_loop (&mut self) { self.looped = !self.looped; }
+    pub fn record_event (&mut self, pulse: usize, message: MidiMessage) {
+        if pulse >= self.length { panic!("extend clip first") }
+        self.notes[pulse].push(message);
+    }
+    /// Check if a range `start..end` contains MIDI Note On `k`
+    pub fn contains_note_on (&self, k: u7, start: usize, end: usize) -> bool {
+        for events in self.notes[start.max(0)..end.min(self.notes.len())].iter() {
+            for event in events.iter() {
+                if let MidiMessage::NoteOn {key,..} = event { if *key == k { return true } }
+            }
+        }
+        false
+    }
+    pub fn stop_all () -> Self {
+        Self::new(
+            "Stop",
+            false,
+            1,
+            Some(vec![vec![MidiMessage::Controller {
+                controller: 123.into(),
+                value: 0.into()
+            }]]),
+            Some(ItemColor::from_rgb(Color::Rgb(32, 32, 32)).into())
+        )
+    }
+}
+
+impl PartialEq for MidiClip {
+    fn eq (&self, other: &Self) -> bool {
+        self.uuid == other.uuid
+    }
+}
+
+impl Eq for MidiClip {}

crates/device/src/sequencer/seq_launch.rs

@@ -0,0 +1,89 @@
+use crate::*;
+
+pub trait HasPlayClip: HasClock {
+
+    fn reset (&self) -> bool;
+
+    fn reset_mut (&mut self) -> &mut bool;
+
+    fn play_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+
+    fn play_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+
+    fn next_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+
+    fn next_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+
+    fn pulses_since_start (&self) -> Option<f64> {
+        if let Some((started, Some(_))) = self.play_clip().as_ref() {
+            let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
+            return Some(elapsed)
+        }
+        None
+    }
+
+    fn pulses_since_start_looped (&self) -> Option<(f64, f64)> {
+        if let Some((started, Some(clip))) = self.play_clip().as_ref() {
+            let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
+            let length  = clip.read().unwrap().length.max(1); // prevent div0 on empty clip
+            let times   = (elapsed as usize / length) as f64;
+            let elapsed = (elapsed as usize % length) as f64;
+            return Some((times, elapsed))
+        }
+        None
+    }
+
+    fn enqueue_next (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
+        *self.next_clip_mut() = Some((self.clock().next_launch_instant(), clip.cloned()));
+        *self.reset_mut() = true;
+    }
+
+    fn play_status (&self) -> impl Content<TuiOut> {
+        let (name, color): (Arc<str>, ItemTheme) = if let Some((_, Some(clip))) = self.play_clip() {
+            let MidiClip { ref name, color, .. } = *clip.read().unwrap();
+            (name.clone(), color)
+        } else {
+            ("".into(), Tui::g(64).into())
+        };
+        let time: String = self.pulses_since_start_looped()
+            .map(|(times, time)|format!("{:>3}x {:>}", times+1.0, self.clock().timebase.format_beats_1(time)))
+            .unwrap_or_else(||String::from("        ")).into();
+        FieldV(color, "Now:", format!("{} {}", time, name))
+    }
+
+    fn next_status (&self) -> impl Content<TuiOut> {
+        let mut time: Arc<str> = String::from("--.-.--").into();
+        let mut name: Arc<str> = String::from("").into();
+        let mut color = ItemTheme::G[64];
+        let clock = self.clock();
+        if let Some((t, Some(clip))) = self.next_clip() {
+            let clip = clip.read().unwrap();
+            name  = clip.name.clone();
+            color = clip.color.clone();
+            time  = {
+                let target  = t.pulse.get();
+                let current = clock.playhead.pulse.get();
+                if target > current {
+                    let remaining = target - current;
+                    format!("-{:>}", clock.timebase.format_beats_1(remaining))
+                } else {
+                    String::new()
+                }
+            }.into()
+        } else if let Some((t, Some(clip))) = self.play_clip() {
+            let clip = clip.read().unwrap();
+            if clip.looped {
+                name  = clip.name.clone();
+                color = clip.color.clone();
+                let target  = t.pulse.get() + clip.length as f64;
+                let current = clock.playhead.pulse.get();
+                if target > current {
+                    time = format!("-{:>}", clock.timebase.format_beats_0(target - current)).into()
+                }
+            } else {
+                name  = "Stop".to_string().into();
+            }
+        };
+        FieldV(color, "Next:", format!("{} {}", time, name))
+    }
+}

crates/device/src/sequencer/seq_model.rs

@@ -0,0 +1,453 @@
+//! MIDI player
+use crate::*;
+use tek_engine::jack::*;
+
+pub trait HasPlayer {
+    fn player (&self) -> &impl MidiPlayerApi;
+    fn player_mut (&mut self) -> &mut impl MidiPlayerApi;
+}
+
+#[macro_export] macro_rules! has_player {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasPlayer for $Struct $(<$($L),*$($T),*>)? {
+            fn player (&$self) -> &impl MidiPlayerApi { &$cb }
+            fn player_mut (&mut $self) -> &mut impl MidiPlayerApi { &mut$cb }
+        }
+    }
+}
+
+pub trait MidiPlayerApi: MidiRecordApi + MidiPlaybackApi + Send + Sync {}
+
+impl MidiPlayerApi for MidiPlayer {}
+
+/// Contains state for playing a clip
+pub struct MidiPlayer {
+    /// State of clock and playhead
+    pub clock:       Clock,
+    /// Start time and clip being played
+    pub play_clip:   Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Start time and next clip
+    pub next_clip:   Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Play input through output.
+    pub monitoring:  bool,
+    /// Write input to sequence.
+    pub recording:   bool,
+    /// Overdub input to sequence.
+    pub overdub:     bool,
+    /// Send all notes off
+    pub reset:       bool, // TODO?: after Some(nframes)
+    /// Record from MIDI ports to current sequence.
+    pub midi_ins:    Vec<JackMidiIn>,
+    /// Play from current sequence to MIDI ports
+    pub midi_outs:   Vec<JackMidiOut>,
+    /// Notes currently held at input
+    pub notes_in:    Arc<RwLock<[bool; 128]>>,
+    /// Notes currently held at output
+    pub notes_out:   Arc<RwLock<[bool; 128]>>,
+    /// MIDI output buffer
+    pub note_buf:    Vec<u8>,
+}
+
+impl Default for MidiPlayer {
+    fn default () -> Self {
+        Self {
+            play_clip:  None,
+            next_clip:  None,
+            recording:  false,
+            monitoring: false,
+            overdub:    false,
+
+            notes_in:   RwLock::new([false;128]).into(),
+            notes_out:  RwLock::new([false;128]).into(),
+            note_buf:   vec![0;8],
+            reset:      true,
+
+            midi_ins:   vec![],
+            midi_outs:  vec![],
+            clock:      Clock::default(),
+        }
+    }
+}
+
+impl MidiPlayer {
+    pub fn new (
+        name:      impl AsRef<str>,
+        jack:      &Jack,
+        clock:     Option<&Clock>,
+        clip:      Option<&Arc<RwLock<MidiClip>>>,
+        midi_from: &[PortConnect],
+        midi_to:   &[PortConnect],
+    ) -> Usually<Self> {
+        let _name = name.as_ref();
+        let clock = clock.cloned().unwrap_or_default();
+        Ok(Self {
+            midi_ins:   vec![JackMidiIn::new(jack,  format!("M/{}", name.as_ref()), midi_from)?,],
+            midi_outs:  vec![JackMidiOut::new(jack, format!("{}/M", name.as_ref()), midi_to)?,  ],
+            play_clip:  clip.map(|clip|(Moment::zero(&clock.timebase), Some(clip.clone()))),
+            clock,
+            note_buf:   vec![0;8],
+            reset:      true,
+            recording:  false,
+            monitoring: false,
+            overdub:    false,
+            next_clip:  None,
+            notes_in:   RwLock::new([false;128]).into(),
+            notes_out:  RwLock::new([false;128]).into(),
+        })
+    }
+}
+
+impl std::fmt::Debug for MidiPlayer {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("MidiPlayer")
+            .field("clock",     &self.clock)
+            .field("play_clip", &self.play_clip)
+            .field("next_clip", &self.next_clip)
+            .finish()
+    }
+}
+
+has_clock!(|self: MidiPlayer|self.clock);
+
+impl HasMidiIns for MidiPlayer {
+    fn midi_ins (&self) -> &Vec<JackMidiIn> { &self.midi_ins }
+    fn midi_ins_mut (&mut self) -> &mut Vec<JackMidiIn> { &mut self.midi_ins }
+}
+
+impl HasMidiOuts for MidiPlayer {
+    fn midi_outs (&self) -> &Vec<JackMidiOut> { &self.midi_outs }
+    fn midi_outs_mut (&mut self) -> &mut Vec<JackMidiOut> { &mut self.midi_outs }
+    fn midi_note (&mut self) -> &mut Vec<u8> { &mut self.note_buf }
+}
+
+/// Hosts the JACK callback for a single MIDI player
+pub struct PlayerAudio<'a, T: MidiPlayerApi>(
+    /// Player
+    pub &'a mut T,
+    /// Note buffer
+    pub &'a mut Vec<u8>,
+    /// Note chunk buffer
+    pub &'a mut Vec<Vec<Vec<u8>>>,
+);
+
+/// JACK process callback for a sequencer's clip player/recorder.
+impl<T: MidiPlayerApi> Audio for PlayerAudio<'_, T> {
+    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        let model    = &mut self.0;
+        let note_buf = &mut self.1;
+        let midi_buf = &mut self.2;
+        // Clear output buffer(s)
+        model.clear(scope, midi_buf, false);
+        // Write chunk of clip to output, handle switchover
+        if model.play(scope, note_buf, midi_buf) {
+            model.switchover(scope, note_buf, midi_buf);
+        }
+        if model.has_midi_ins() {
+            if model.recording() || model.monitoring() {
+                // Record and/or monitor input
+                model.record(scope, midi_buf)
+            } else if model.has_midi_outs() && model.monitoring() {
+                // Monitor input to output
+                model.monitor(scope, midi_buf)
+            }
+        }
+        // Write to output port(s)
+        model.write(scope, midi_buf);
+        Control::Continue
+    }
+}
+
+impl MidiRecordApi for MidiPlayer {
+    fn recording (&self) -> bool {
+        self.recording
+    }
+    fn recording_mut (&mut self) -> &mut bool {
+        &mut self.recording
+    }
+    fn monitoring (&self) -> bool {
+        self.monitoring
+    }
+    fn monitoring_mut (&mut self) -> &mut bool {
+        &mut self.monitoring
+    }
+    fn overdub (&self) -> bool {
+        self.overdub
+    }
+    fn overdub_mut (&mut self) -> &mut bool {
+        &mut self.overdub
+    }
+    fn notes_in (&self) -> &Arc<RwLock<[bool; 128]>> {
+        &self.notes_in
+    }
+}
+
+impl MidiPlaybackApi for MidiPlayer {
+    fn notes_out (&self) -> &Arc<RwLock<[bool; 128]>> {
+        &self.notes_out
+    }
+}
+
+impl HasPlayClip for MidiPlayer {
+    fn reset (&self) -> bool {
+        self.reset
+    }
+    fn reset_mut (&mut self) -> &mut bool {
+        &mut self.reset
+    }
+    fn play_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.play_clip
+    }
+    fn play_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.play_clip
+    }
+    fn next_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.next_clip
+    }
+    fn next_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.next_clip
+    }
+}
+
+pub trait MidiRecordApi: HasClock + HasPlayClip + HasMidiIns {
+    fn notes_in (&self) -> &Arc<RwLock<[bool;128]>>;
+
+    fn recording (&self) -> bool;
+
+    fn recording_mut (&mut self) -> &mut bool;
+
+    fn toggle_record (&mut self) {
+        *self.recording_mut() = !self.recording();
+    }
+
+    fn monitoring (&self) -> bool;
+
+    fn monitoring_mut (&mut self) -> &mut bool;
+
+    fn toggle_monitor (&mut self) {
+        *self.monitoring_mut() = !self.monitoring();
+    }
+
+    fn overdub (&self) -> bool;
+
+    fn overdub_mut (&mut self) -> &mut bool;
+
+    fn toggle_overdub (&mut self) {
+        *self.overdub_mut() = !self.overdub();
+    }
+
+    fn monitor (&mut self, scope: &ProcessScope, midi_buf: &mut Vec<Vec<Vec<u8>>>) {
+        // For highlighting keys and note repeat
+        let notes_in = self.notes_in().clone();
+        let monitoring = self.monitoring();
+        for input in self.midi_ins_mut().iter() {
+            for (sample, event, bytes) in parse_midi_input(input.port().iter(scope)) {
+                if let LiveEvent::Midi { message, .. } = event {
+                    if monitoring {
+                        midi_buf[sample].push(bytes.to_vec());
+                    }
+                    // FIXME: don't lock on every event!
+                    update_keys(&mut notes_in.write().unwrap(), &message);
+                }
+            }
+        }
+    }
+
+    fn record (&mut self, scope: &ProcessScope, midi_buf: &mut Vec<Vec<Vec<u8>>>) {
+        if self.monitoring() {
+            self.monitor(scope, midi_buf);
+        }
+        if !self.clock().is_rolling() {
+            return
+        }
+        if let Some((started, ref clip)) = self.play_clip().clone() {
+            self.record_clip(scope, started, clip, midi_buf);
+        }
+        if let Some((_start_at, _clip)) = &self.next_clip() {
+            self.record_next();
+        }
+    }
+
+    fn record_clip (
+        &mut self,
+        scope:     &ProcessScope,
+        started:   Moment,
+        clip:      &Option<Arc<RwLock<MidiClip>>>,
+        _midi_buf: &mut Vec<Vec<Vec<u8>>>
+    ) {
+        if let Some(clip) = clip {
+            let sample0    = scope.last_frame_time() as usize;
+            let start      = started.sample.get() as usize;
+            let _recording = self.recording();
+            let timebase   = self.clock().timebase().clone();
+            let quant      = self.clock().quant.get();
+            let mut clip = clip.write().unwrap();
+            let length     = clip.length;
+            for input in self.midi_ins_mut().iter() {
+                for (sample, event, _bytes) in parse_midi_input(input.port().iter(scope)) {
+                    if let LiveEvent::Midi { message, .. } = event {
+                        clip.record_event({
+                            let sample    = (sample0 + sample - start) as f64;
+                            let pulse     = timebase.samples_to_pulse(sample);
+                            let quantized = (pulse / quant).round() * quant;
+                            quantized as usize % length
+                        }, message);
+                    }
+                }
+            }
+        }
+    }
+
+    fn record_next (&mut self) {
+        // TODO switch to next clip and record into it
+    }
+
+}
+
+pub trait MidiPlaybackApi: HasPlayClip + HasClock + HasMidiOuts {
+
+    fn notes_out (&self) -> &Arc<RwLock<[bool;128]>>;
+
+    /// Clear the section of the output buffer that we will be using,
+    /// emitting "all notes off" at start of buffer if requested.
+    fn clear (
+        &mut self, scope: &ProcessScope, out: &mut [Vec<Vec<u8>>], reset: bool
+    ) {
+        let n_frames = (scope.n_frames() as usize).min(out.len());
+        for frame in &mut out[0..n_frames] {
+            frame.clear();
+        }
+        if reset {
+            all_notes_off(out);
+        }
+    }
+
+    /// Output notes from clip to MIDI output ports.
+    fn play (
+        &mut self, scope: &ProcessScope, note_buf: &mut Vec<u8>, out: &mut [Vec<Vec<u8>>]
+    ) -> bool {
+        if !self.clock().is_rolling() {
+            return false
+        }
+        // If a clip is playing, write a chunk of MIDI events from it to the output buffer.
+        // If no clip is playing, prepare for switchover immediately.
+        self.play_clip().as_ref().map_or(true, |(started, clip)|{
+            self.play_chunk(scope, note_buf, out, started, clip)
+        })
+    }
+
+    /// Handle switchover from current to next playing clip.
+    fn switchover (
+        &mut self, scope: &ProcessScope, note_buf: &mut Vec<u8>, out: &mut [Vec<Vec<u8>>]
+    ) {
+        if !self.clock().is_rolling() {
+            return
+        }
+        let sample0 = scope.last_frame_time() as usize;
+        //let samples = scope.n_frames() as usize;
+        if let Some((start_at, clip)) = &self.next_clip() {
+            let start  = start_at.sample.get() as usize;
+            let sample = self.clock().started.read().unwrap()
+                .as_ref().unwrap().sample.get() as usize;
+            // If it's time to switch to the next clip:
+            if start <= sample0.saturating_sub(sample) {
+                // Samples elapsed since clip was supposed to start
+                let _skipped = sample0 - start;
+                // Switch over to enqueued clip
+                let started = Moment::from_sample(self.clock().timebase(), start as f64);
+                // Launch enqueued clip
+                *self.play_clip_mut() = Some((started, clip.clone()));
+                // Unset enqueuement (TODO: where to implement looping?)
+                *self.next_clip_mut() = None;
+                // Fill in remaining ticks of chunk from next clip.
+                self.play(scope, note_buf, out);
+            }
+        }
+    }
+
+    fn play_chunk (
+        &self,
+        scope:    &ProcessScope,
+        note_buf: &mut Vec<u8>,
+        out:      &mut [Vec<Vec<u8>>],
+        started:  &Moment,
+        clip:   &Option<Arc<RwLock<MidiClip>>>
+    ) -> bool {
+        // First sample to populate. Greater than 0 means that the first
+        // pulse of the clip falls somewhere in the middle of the chunk.
+        let sample = (scope.last_frame_time() as usize).saturating_sub(
+            started.sample.get() as usize +
+            self.clock().started.read().unwrap().as_ref().unwrap().sample.get() as usize
+        );
+        // Iterator that emits sample (index into output buffer at which to write MIDI event)
+        // paired with pulse (index into clip from which to take the MIDI event) for each
+        // sample of the output buffer that corresponds to a MIDI pulse.
+        let pulses = self.clock().timebase().pulses_between_samples(sample, sample + scope.n_frames() as usize);
+        // Notes active during current chunk.
+        let notes  = &mut self.notes_out().write().unwrap();
+        let length = clip.as_ref().map_or(0, |p|p.read().unwrap().length);
+        for (sample, pulse) in pulses {
+            // If a next clip is enqueued, and we're past the end of the current one,
+            // break the loop here (FIXME count pulse correctly)
+            let past_end = if clip.is_some() { pulse >= length } else { true };
+            if self.next_clip().is_some() && past_end {
+                return true
+            }
+            // If there's a currently playing clip, output notes from it to buffer:
+            if let Some(ref clip) = clip {
+                Self::play_pulse(clip, pulse, sample, note_buf, out, notes)
+            }
+        }
+        false
+    }
+
+    fn play_pulse (
+        clip:   &RwLock<MidiClip>,
+        pulse:    usize,
+        sample:   usize,
+        note_buf: &mut Vec<u8>,
+        out:      &mut [Vec<Vec<u8>>],
+        notes:    &mut [bool;128]
+    ) {
+        // Source clip from which the MIDI events will be taken.
+        let clip = clip.read().unwrap();
+        // Clip with zero length is not processed
+        if clip.length > 0 {
+            // Current pulse index in source clip
+            let pulse = pulse % clip.length;
+            // Output each MIDI event from clip at appropriate frames of output buffer:
+            for message in clip.notes[pulse].iter() {
+                // Clear output buffer for this MIDI event.
+                note_buf.clear();
+                // TODO: support MIDI channels other than CH1.
+                let channel = 0.into();
+                // Serialize MIDI event into message buffer.
+                LiveEvent::Midi { channel, message: *message }
+                    .write(note_buf)
+                    .unwrap();
+                // Append serialized message to output buffer.
+                out[sample].push(note_buf.clone());
+                // Update the list of currently held notes.
+                update_keys(&mut*notes, message);
+            }
+        }
+    }
+
+    /// Write a chunk of MIDI data from the output buffer to all assigned output ports.
+    fn write (&mut self, scope: &ProcessScope, out: &[Vec<Vec<u8>>]) {
+        let samples = scope.n_frames() as usize;
+        for port in self.midi_outs_mut().iter_mut() {
+            Self::write_port(&mut port.port_mut().writer(scope), samples, out)
+        }
+    }
+
+    /// Write a chunk of MIDI data from the output buffer to an output port.
+    fn write_port (writer: &mut MidiWriter, samples: usize, out: &[Vec<Vec<u8>>]) {
+        for (time, events) in out.iter().enumerate().take(samples) {
+            for bytes in events.iter() {
+                writer.write(&RawMidi { time: time as u32, bytes }).unwrap_or_else(|_|{
+                    panic!("Failed to write MIDI data: {bytes:?}");
+                });
+            }
+        }
+    }
+}

crates/device/src/sequencer/seq_view.rs

@@ -0,0 +1,66 @@
+use crate::*;
+
+pub trait MidiViewer: HasSize<TuiOut> + MidiRange + MidiPoint + Debug + Send + Sync {
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize);
+    fn redraw (&self);
+    fn clip (&self) -> &Option<Arc<RwLock<MidiClip>>>;
+    fn clip_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>>;
+    fn set_clip (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
+        *self.clip_mut() = clip.cloned();
+        self.redraw();
+    }
+    /// Make sure cursor is within note range
+    fn autoscroll (&self) {
+        let note_pos = self.note_pos().min(127);
+        let note_lo    = self.note_lo().get();
+        let note_hi    = self.note_hi();
+        if note_pos < note_lo {
+            self.note_lo().set(note_pos);
+        } else if note_pos > note_hi {
+            self.note_lo().set((note_lo + note_pos).saturating_sub(note_hi));
+        }
+    }
+    /// Make sure time range is within display
+    fn autozoom (&self) {
+        if self.time_lock().get() {
+            let time_len  = self.time_len().get();
+            let time_axis = self.time_axis().get();
+            let time_zoom = self.time_zoom().get();
+            loop {
+                let time_zoom = self.time_zoom().get();
+                let time_area = time_axis * time_zoom;
+                if time_area > time_len {
+                    let next_time_zoom = NoteDuration::prev(time_zoom);
+                    if next_time_zoom <= 1 {
+                        break
+                    }
+                    let next_time_area = time_axis * next_time_zoom;
+                    if next_time_area >= time_len {
+                        self.time_zoom().set(next_time_zoom);
+                    } else {
+                        break
+                    }
+                } else if time_area < time_len {
+                    let prev_time_zoom = NoteDuration::next(time_zoom);
+                    if prev_time_zoom > 384 {
+                        break
+                    }
+                    let prev_time_area = time_axis * prev_time_zoom;
+                    if prev_time_area <= time_len {
+                        self.time_zoom().set(prev_time_zoom);
+                    } else {
+                        break
+                    }
+                }
+            }
+            if time_zoom != self.time_zoom().get() {
+                self.redraw()
+            }
+        }
+        //while time_len.div_ceil(time_zoom) > time_axis {
+            //println!("\r{time_len} {time_zoom} {time_axis}");
+            //time_zoom = Note::next(time_zoom);
+        //}
+        //self.time_zoom().set(time_zoom);
+    }
+}