wip: refactor into fewer crates, pt.2

crates/device/Cargo.toml

@@ -6,12 +6,14 @@ version = { workspace = true }
 [dependencies]
 tengri     = { workspace = true }
 tek_engine = { workspace = true }
+uuid       = { workspace = true, optional = true }
 livi       = { workspace = true, optional = true }
 symphonia  = { workspace = true, optional = true }
 wavers     = { workspace = true, optional = true }
 
 [features]
-default   = [ "sequencer", "sampler" ]
+default   = [ "clock", "sequencer", "sampler" ]
 lv2       = [ "livi" ]
 sampler   = [ "symphonia", "wavers" ]
-sequencer = []
+sequencer = [ "clock", "uuid" ]
+clock     = []

crates/device/src/clock.rs

@@ -0,0 +1,16 @@
+mod clock_api;   pub use self::clock_api::*;
+mod clock_model; pub use self::clock_model::*;
+
+pub trait HasClock: Send + Sync {
+    fn clock (&self) -> &Clock;
+    fn clock_mut (&mut self) -> &mut Clock;
+}
+
+#[macro_export] macro_rules! has_clock {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasClock for $Struct $(<$($L),*$($T),*>)? {
+            fn clock (&$self) -> &Clock { &$cb }
+            fn clock_mut (&mut $self) -> &mut Clock { &mut $cb }
+        }
+    }
+}

crates/device/src/clock/clock_api.rs

@@ -0,0 +1,55 @@
+use crate::*;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum ClockCommand {
+    Play(Option<u32>),
+    Pause(Option<u32>),
+    SeekUsec(f64),
+    SeekSample(f64),
+    SeekPulse(f64),
+    SetBpm(f64),
+    SetQuant(f64),
+    SetSync(f64),
+}
+
+provide_num!(u32: |self: Clock| {});
+
+provide!(f64: |self: Clock| {});
+
+atom_command!(ClockCommand: |state: Clock| {
+    ("play"        []       Some(Self::Play(None)))
+    ("play"        [t: u32] Some(Self::Play(t)))
+    ("pause"       []       Some(Self::Pause(None)))
+    ("pause"       [t: u32] Some(Self::Pause(t)))
+    ("toggle"      []       Some(if state.is_rolling() { Self::Pause(None) } else { Self::Play(None) }))
+    ("toggle"      [t: u32] Some(if state.is_rolling() { Self::Pause(t) } else { Self::Play(t) }))
+    ("seek/usec"   [t: f64] Some(Self::SeekUsec(t.expect("no usec"))))
+    ("seek/pulse"  [t: f64] Some(Self::SeekPulse(t.expect("no pulse"))))
+    ("seek/sample" [t: f64] Some(Self::SeekSample(t.expect("no sample"))))
+    ("set/bpm"     [t: f64] Some(Self::SetBpm(t.expect("no bpm"))))
+    ("set/sync"    [t: f64] Some(Self::SetSync(t.expect("no sync"))))
+    ("set/quant"   [t: f64] Some(Self::SetQuant(t.expect("no quant"))))
+});
+
+impl<T: HasClock> Command<T> for ClockCommand {
+    fn execute (self, state: &mut T) -> Perhaps<Self> {
+        self.execute(state.clock_mut())
+    }
+}
+
+impl Command<Clock> for ClockCommand {
+    fn execute (self, state: &mut Clock) -> Perhaps<Self> {
+        use ClockCommand::*;
+        match self {
+            Play(start)        => state.play_from(start)?,
+            Pause(pause)       => state.pause_at(pause)?,
+            SeekUsec(usec)     => state.playhead.update_from_usec(usec),
+            SeekSample(sample) => state.playhead.update_from_sample(sample),
+            SeekPulse(pulse)   => state.playhead.update_from_pulse(pulse),
+            SetBpm(bpm)        => return Ok(Some(SetBpm(state.timebase().bpm.set(bpm)))),
+            SetQuant(quant)    => return Ok(Some(SetQuant(state.quant.set(quant)))),
+            SetSync(sync)      => return Ok(Some(SetSync(state.sync.set(sync)))),
+        };
+        Ok(None)
+    }
+}

crates/device/src/clock/clock_model.rs

@@ -0,0 +1,180 @@
+use crate::*;
+
+#[derive(Clone, Default)]
+pub struct Clock {
+    /// JACK transport handle.
+    pub transport: Arc<Option<tek_engine::jack::Transport>>,
+    /// Global temporal resolution (shared by [Moment] fields)
+    pub timebase:  Arc<Timebase>,
+    /// Current global sample and usec (monotonic from JACK clock)
+    pub global:    Arc<Moment>,
+    /// Global sample and usec at which playback started
+    pub started:   Arc<RwLock<Option<Moment>>>,
+    /// Playback offset (when playing not from start)
+    pub offset:    Arc<Moment>,
+    /// Current playhead position
+    pub playhead:  Arc<Moment>,
+    /// Note quantization factor
+    pub quant:     Arc<Quantize>,
+    /// Launch quantization factor
+    pub sync:      Arc<LaunchSync>,
+    /// Size of buffer in samples
+    pub chunk:     Arc<AtomicUsize>,
+    /// For syncing the clock to an external source
+    pub midi_in:   Arc<RwLock<Option<JackMidiIn>>>,
+    /// For syncing other devices to this clock
+    pub midi_out:  Arc<RwLock<Option<JackMidiOut>>>,
+    /// For emitting a metronome
+    pub click_out: Arc<RwLock<Option<JackAudioOut>>>,
+}
+
+impl std::fmt::Debug for Clock {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("Clock")
+            .field("timebase", &self.timebase)
+            .field("chunk",    &self.chunk)
+            .field("quant",    &self.quant)
+            .field("sync",     &self.sync)
+            .field("global",   &self.global)
+            .field("playhead", &self.playhead)
+            .field("started",  &self.started)
+            .finish()
+    }
+}
+
+impl Clock {
+    pub fn new (jack: &Jack, bpm: Option<f64>) -> Usually<Self> {
+        let (chunk, transport) = jack.with_client(|c|(c.buffer_size(), c.transport()));
+        let timebase = Arc::new(Timebase::default());
+        let clock = Self {
+            quant:     Arc::new(24.into()),
+            sync:      Arc::new(384.into()),
+            transport: Arc::new(Some(transport)),
+            chunk:     Arc::new((chunk as usize).into()),
+            global:    Arc::new(Moment::zero(&timebase)),
+            playhead:  Arc::new(Moment::zero(&timebase)),
+            offset:    Arc::new(Moment::zero(&timebase)),
+            started:   RwLock::new(None).into(),
+            timebase,
+            midi_in:   Arc::new(RwLock::new(Some(JackMidiIn::new(jack, "M/clock", &[])?))),
+            midi_out:  Arc::new(RwLock::new(Some(JackMidiOut::new(jack, "clock/M", &[])?))),
+            click_out: Arc::new(RwLock::new(Some(JackAudioOut::new(jack, "click", &[])?))),
+        };
+        if let Some(bpm) = bpm {
+            clock.timebase.bpm.set(bpm);
+        }
+        Ok(clock)
+    }
+    pub fn timebase (&self) -> &Arc<Timebase> {
+        &self.timebase
+    }
+    /// Current sample rate
+    pub fn sr (&self) -> &SampleRate {
+        &self.timebase.sr
+    }
+    /// Current tempo
+    pub fn bpm (&self) -> &BeatsPerMinute {
+        &self.timebase.bpm
+    }
+    /// Current MIDI resolution
+    pub fn ppq (&self) -> &PulsesPerQuaver {
+        &self.timebase.ppq
+    }
+    /// Next pulse that matches launch sync (for phrase switchover)
+    pub fn next_launch_pulse (&self) -> usize {
+        let sync  = self.sync.get() as usize;
+        let pulse = self.playhead.pulse.get() as usize;
+        if pulse % sync == 0 {
+            pulse
+        } else {
+            (pulse / sync + 1) * sync
+        }
+    }
+    /// Start playing, optionally seeking to a given location beforehand
+    pub fn play_from (&self, start: Option<u32>) -> Usually<()> {
+        if let Some(transport) = self.transport.as_ref() {
+            if let Some(start) = start {
+                transport.locate(start)?;
+            }
+            transport.start()?;
+        }
+        Ok(())
+    }
+    /// Pause, optionally seeking to a given location afterwards
+    pub fn pause_at (&self, pause: Option<u32>) -> Usually<()> {
+        if let Some(transport) = self.transport.as_ref() {
+            transport.stop()?;
+            if let Some(pause) = pause {
+                transport.locate(pause)?;
+            }
+        }
+        Ok(())
+    }
+    /// Is currently paused?
+    pub fn is_stopped (&self) -> bool {
+        self.started.read().unwrap().is_none()
+    }
+    /// Is currently playing?
+    pub fn is_rolling (&self) -> bool {
+        self.started.read().unwrap().is_some()
+    }
+    /// Update chunk size
+    pub fn set_chunk (&self, n_frames: usize) {
+        self.chunk.store(n_frames, Relaxed);
+    }
+    pub fn update_from_scope (&self, scope: &ProcessScope) -> Usually<()> {
+        // Store buffer length
+        self.set_chunk(scope.n_frames() as usize);
+
+        // Store reported global frame and usec
+        let tek_engine::jack::CycleTimes { current_frames, current_usecs, .. } = scope.cycle_times()?;
+        self.global.sample.set(current_frames as f64);
+        self.global.usec.set(current_usecs as f64);
+
+        let mut started = self.started.write().unwrap();
+
+        // If transport has just started or just stopped,
+        // update starting point:
+        if let Some(transport) = self.transport.as_ref() {
+            match (transport.query_state()?, started.as_ref()) {
+                (TransportState::Rolling, None) => {
+                    let moment = Moment::zero(&self.timebase);
+                    moment.sample.set(current_frames as f64);
+                    moment.usec.set(current_usecs as f64);
+                    *started = Some(moment);
+                },
+                (TransportState::Stopped, Some(_)) => {
+                    *started = None;
+                },
+                _ => {}
+            };
+        }
+
+        self.playhead.update_from_sample(started.as_ref()
+            .map(|started|current_frames as f64 - started.sample.get())
+            .unwrap_or(0.));
+
+        Ok(())
+    }
+
+    pub fn bbt (&self) -> tek_engine::jack::PositionBBT {
+        let pulse = self.playhead.pulse.get() as i32;
+        let ppq   = self.timebase.ppq.get() as i32;
+        let bpm   = self.timebase.bpm.get();
+        let bar   = (pulse / ppq) / 4;
+        tek_engine::jack::PositionBBT {
+            bar:              1 + bar,
+            beat:             1 + (pulse / ppq) % 4,
+            tick:             (pulse % ppq),
+            bar_start_tick:   (bar * 4 * ppq) as f64,
+            beat_type:        4.,
+            beats_per_bar:    4.,
+            beats_per_minute: bpm,
+            ticks_per_beat:   ppq as f64
+        }
+    }
+
+    pub fn next_launch_instant (&self) -> Moment {
+        Moment::from_pulse(self.timebase(), self.next_launch_pulse() as f64)
+    }
+}

crates/device/src/lib.rs

@@ -0,0 +1,38 @@
+#![feature(let_chains)]
+
+pub(crate) use std::cmp::Ord;
+pub(crate) use std::fmt::{Debug, Formatter};
+pub(crate) use std::thread::JoinHandle;
+pub(crate) use std::sync::{Arc, RwLock, atomic::{AtomicUsize, Ordering::Relaxed}};
+pub(crate) use std::fs::File;
+pub(crate) use std::path::PathBuf;
+pub(crate) use std::error::Error;
+pub(crate) use std::ffi::OsString;
+
+pub(crate) use ::tengri::{dsl::*, input::*, output::*, tui::{*, ratatui::prelude::*}};
+pub(crate) use ::tek_engine::*;
+pub(crate) use ::tek_engine::midi::{u7, LiveEvent, MidiMessage};
+pub(crate) use ::tek_engine::jack::{Control, ProcessScope, MidiWriter, RawMidi};
+pub(crate) use ratatui::{prelude::Rect, widgets::{Widget, canvas::{Canvas, Line}}};
+
+#[cfg(feature = "clock")] mod clock;
+#[cfg(feature = "clock")] pub use self::clock::*;
+
+#[cfg(feature = "sequencer")] mod sequencer;
+#[cfg(feature = "sequencer")] pub use self::sequencer::*;
+
+#[cfg(feature = "sampler")] mod sampler;
+#[cfg(feature = "sampler")] pub use self::sampler::*;
+
+#[cfg(feature = "plugin")] mod plugin;
+#[cfg(feature = "plugin")] pub use self::plugin::*;
+
+#[derive(Debug)]
+pub enum Device {
+    #[cfg(feature = "sequencer")]
+    Sequencer(MidiPlayer),
+    #[cfg(feature = "sampler")]
+    Sampler(Sampler),
+    #[cfg(feature = "plugin")]
+    Plugin(Plugin),
+}

crates/device/src/plugin.rs

@@ -1,8 +1,281 @@
-mod plugin; pub use self::plugin::*;
-mod lv2;    pub use self::lv2::*;
-pub(crate) use std::cmp::Ord;
-pub(crate) use std::fmt::{Debug, Formatter};
-pub(crate) use std::sync::{Arc, RwLock};
-pub(crate) use std::thread::JoinHandle;
-pub(crate) use ::tek_jack::{*, jack::*};
-pub(crate) use ::tengri::{output::*, tui::{*, ratatui::prelude::*}};
+use crate::*;
+
+mod lv2;
+mod lv2_gui;
+mod lv2_tui;
+mod vst2_tui;
+mod vst3_tui;
+
+/// A plugin device.
+#[derive(Debug)]
+pub struct Plugin {
+    /// JACK client handle (needs to not be dropped for standalone mode to work).
+    pub jack:       Jack,
+    pub name:       Arc<str>,
+    pub path:       Option<Arc<str>>,
+    pub plugin:     Option<PluginKind>,
+    pub selected:   usize,
+    pub mapping:    bool,
+    pub midi_ins:   Vec<Port<MidiIn>>,
+    pub midi_outs:  Vec<Port<MidiOut>>,
+    pub audio_ins:  Vec<Port<AudioIn>>,
+    pub audio_outs: Vec<Port<AudioOut>>,
+}
+
+/// Supported plugin formats.
+#[derive(Default)]
+pub enum PluginKind {
+    #[default] None,
+    LV2(LV2Plugin),
+    VST2 { instance: () /*::vst::host::PluginInstance*/ },
+    VST3,
+}
+
+impl Debug for PluginKind {
+    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        write!(f, "{}", match self {
+            Self::None     => "(none)",
+            Self::LV2(_)   => "LV2",
+            Self::VST2{..} => "VST2",
+            Self::VST3     => "VST3",
+        })
+    }
+}
+impl Plugin {
+    pub fn new_lv2 (
+        jack: &Jack,
+        name: &str,
+        path: &str,
+    ) -> Usually<Self> {
+        Ok(Self {
+            jack:       jack.clone(),
+            name:       name.into(),
+            path:       Some(String::from(path).into()),
+            plugin:     Some(PluginKind::LV2(LV2Plugin::new(path)?)),
+            selected:   0,
+            mapping:    false,
+            midi_ins:   vec![],
+            midi_outs:  vec![],
+            audio_ins:  vec![],
+            audio_outs: vec![],
+        })
+    }
+}
+
+pub struct PluginAudio(Arc<RwLock<Plugin>>);
+from!(|model: &Arc<RwLock<Plugin>>| PluginAudio = Self(model.clone()));
+audio!(|self: PluginAudio, _client, scope|{
+    let state = &mut*self.0.write().unwrap();
+    match state.plugin.as_mut() {
+        Some(PluginKind::LV2(LV2Plugin {
+            features,
+            ref mut instance,
+            ref mut input_buffer,
+            ..
+        })) => {
+            let urid = features.midi_urid();
+            input_buffer.clear();
+            for port in state.midi_ins.iter() {
+                let mut atom = ::livi::event::LV2AtomSequence::new(
+                    &features,
+                    scope.n_frames() as usize
+                );
+                for event in port.iter(scope) {
+                    match event.bytes.len() {
+                        3 => atom.push_midi_event::<3>(
+                            event.time as i64,
+                            urid,
+                            &event.bytes[0..3]
+                        ).unwrap(),
+                        _ => {}
+                    }
+                }
+                input_buffer.push(atom);
+            }
+            let mut outputs = vec![];
+            for _ in state.midi_outs.iter() {
+                outputs.push(::livi::event::LV2AtomSequence::new(
+                    features,
+                    scope.n_frames() as usize
+                ));
+            }
+            let ports = ::livi::EmptyPortConnections::new()
+                .with_atom_sequence_inputs(input_buffer.iter())
+                .with_atom_sequence_outputs(outputs.iter_mut())
+                .with_audio_inputs(state.audio_ins.iter().map(|o|o.as_slice(scope)))
+                .with_audio_outputs(state.audio_outs.iter_mut().map(|o|o.as_mut_slice(scope)));
+            unsafe {
+                instance.run(scope.n_frames() as usize, ports).unwrap()
+            };
+        },
+        _ => todo!("only lv2 is supported")
+    }
+    Control::Continue
+});
+
+    //fn jack_from_lv2 (name: &str, plugin: &::livi::Plugin) -> Usually<Jack> {
+        //let counts = plugin.port_counts();
+        //let mut jack = Jack::new(name)?;
+        //for i in 0..counts.atom_sequence_inputs {
+            //jack = jack.midi_in(&format!("midi-in-{i}"))
+        //}
+        //for i in 0..counts.atom_sequence_outputs {
+            //jack = jack.midi_out(&format!("midi-out-{i}"));
+        //}
+        //for i in 0..counts.audio_inputs {
+            //jack = jack.audio_in(&format!("audio-in-{i}"));
+        //}
+        //for i in 0..counts.audio_outputs {
+            //jack = jack.audio_out(&format!("audio-out-{i}"));
+        //}
+        //Ok(jack)
+    //}
+
+impl Plugin {
+    /// Create a plugin host device.
+    pub fn new (
+        jack: &Jack,
+        name: &str,
+    ) -> Usually<Self> {
+        Ok(Self {
+            //_engine:    Default::default(),
+            jack:       jack.clone(),
+            name:       name.into(),
+            path:       None,
+            plugin:     None,
+            selected:   0,
+            mapping:    false,
+            audio_ins:  vec![],
+            audio_outs: vec![],
+            midi_ins:   vec![],
+            midi_outs:  vec![],
+            //ports:      JackPorts::default()
+        })
+    }
+}
+impl Content<TuiOut> for Plugin {
+    fn render (&self, to: &mut TuiOut) {
+        let area = to.area();
+        let [x, y, _, height] = area;
+        let mut width = 20u16;
+        match &self.plugin {
+            Some(PluginKind::LV2(LV2Plugin { port_list, instance, .. })) => {
+                let start = self.selected.saturating_sub((height as usize / 2).saturating_sub(1));
+                let end   = start + height as usize - 2;
+                //draw_box(buf, Rect { x, y, width, height });
+                for i in start..end {
+                    if let Some(port) = port_list.get(i) {
+                        let value = if let Some(value) = instance.control_input(port.index) {
+                            value
+                        } else {
+                            port.default_value
+                        };
+                        //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
+                        let label = &format!("{:25} = {value:.03}", port.name);
+                        width = width.max(label.len() as u16 + 4);
+                        let style = if i == self.selected {
+                            Some(Style::default().green())
+                        } else {
+                            None
+                        } ;
+                        to.blit(&label, x + 2, y + 1 + i as u16 - start as u16, style);
+                    } else {
+                        break
+                    }
+                }
+            },
+            _ => {}
+        };
+        draw_header(self, to, x, y, width);
+    }
+}
+
+fn draw_header (state: &Plugin, to: &mut TuiOut, x: u16, y: u16, w: u16) {
+    let style  = Style::default().gray();
+    let label1 = format!(" {}", state.name);
+    to.blit(&label1, x + 1, y, Some(style.white().bold()));
+    if let Some(ref path) = state.path {
+        let label2 = format!("{}…", &path[..((w as usize - 10).min(path.len()))]);
+        to.blit(&label2, x + 2 + label1.len() as u16, y, Some(style.not_dim()));
+    }
+    //Ok(Rect { x, y, width: w, height: 1 })
+}
+
+//handle!(TuiIn: |self:Plugin, from|{
+    //match from.event() {
+        //kpat!(KeyCode::Up) => {
+            //self.selected = self.selected.saturating_sub(1);
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Down) => {
+            //self.selected = (self.selected + 1).min(match &self.plugin {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+                //_ => unimplemented!()
+            //});
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::PageUp) => {
+            //self.selected = self.selected.saturating_sub(8);
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::PageDown) => {
+            //self.selected = (self.selected + 10).min(match &self.plugin {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
+                //_ => unimplemented!()
+            //});
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Char(',')) => {
+            //match self.plugin.as_mut() {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                    //let index = port_list[self.selected].index;
+                    //if let Some(value) = instance.control_input(index) {
+                        //instance.set_control_input(index, value - 0.01);
+                    //}
+                //},
+                //_ => {}
+            //}
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Char('.')) => {
+            //match self.plugin.as_mut() {
+                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
+                    //let index = port_list[self.selected].index;
+                    //if let Some(value) = instance.control_input(index) {
+                        //instance.set_control_input(index, value + 0.01);
+                    //}
+                //},
+                //_ => {}
+            //}
+            //Ok(Some(true))
+        //},
+        //kpat!(KeyCode::Char('g')) => {
+            //match self.plugin {
+                ////Some(PluginKind::LV2(ref mut plugin)) => {
+                    ////plugin.ui_thread = Some(run_lv2_ui(LV2PluginUI::new()?)?);
+                ////},
+                //Some(_) => unreachable!(),
+                //None => {}
+            //}
+            //Ok(Some(true))
+        //},
+        //_ => Ok(None)
+    //}
+//});
+
+//from_atom!("plugin/lv2" => |jack: &Jack, args| -> Plugin {
+    //let mut name = String::new();
+    //let mut path = String::new();
+    //atom!(atom in args {
+        //Atom::Map(map) => {
+            //if let Some(Atom::Str(n)) = map.get(&Atom::Key(":name")) {
+                //name = String::from(*n);
+            //}
+            //if let Some(Atom::Str(p)) = map.get(&Atom::Key(":path")) {
+                //path = String::from(*p);
+            //}
+        //},
+        //_ => panic!("unexpected in lv2 '{name}'"),
+    //});
+    //Plugin::new_lv2(jack, &name, &path)
+//});

crates/device/src/plugin/plugin.rs

@@ -1,275 +0,0 @@
-use crate::*;
-
-/// A plugin device.
-#[derive(Debug)]
-pub struct Plugin {
-    /// JACK client handle (needs to not be dropped for standalone mode to work).
-    pub jack:       Jack,
-    pub name:       Arc<str>,
-    pub path:       Option<Arc<str>>,
-    pub plugin:     Option<PluginKind>,
-    pub selected:   usize,
-    pub mapping:    bool,
-    pub midi_ins:   Vec<Port<MidiIn>>,
-    pub midi_outs:  Vec<Port<MidiOut>>,
-    pub audio_ins:  Vec<Port<AudioIn>>,
-    pub audio_outs: Vec<Port<AudioOut>>,
-}
-
-/// Supported plugin formats.
-#[derive(Default)]
-pub enum PluginKind {
-    #[default] None,
-    LV2(LV2Plugin),
-    VST2 { instance: () /*::vst::host::PluginInstance*/ },
-    VST3,
-}
-
-impl Debug for PluginKind {
-    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-        write!(f, "{}", match self {
-            Self::None     => "(none)",
-            Self::LV2(_)   => "LV2",
-            Self::VST2{..} => "VST2",
-            Self::VST3     => "VST3",
-        })
-    }
-}
-impl Plugin {
-    pub fn new_lv2 (
-        jack: &Jack,
-        name: &str,
-        path: &str,
-    ) -> Usually<Self> {
-        Ok(Self {
-            jack:       jack.clone(),
-            name:       name.into(),
-            path:       Some(String::from(path).into()),
-            plugin:     Some(PluginKind::LV2(LV2Plugin::new(path)?)),
-            selected:   0,
-            mapping:    false,
-            midi_ins:   vec![],
-            midi_outs:  vec![],
-            audio_ins:  vec![],
-            audio_outs: vec![],
-        })
-    }
-}
-
-pub struct PluginAudio(Arc<RwLock<Plugin>>);
-from!(|model: &Arc<RwLock<Plugin>>| PluginAudio = Self(model.clone()));
-audio!(|self: PluginAudio, _client, scope|{
-    let state = &mut*self.0.write().unwrap();
-    match state.plugin.as_mut() {
-        Some(PluginKind::LV2(LV2Plugin {
-            features,
-            ref mut instance,
-            ref mut input_buffer,
-            ..
-        })) => {
-            let urid = features.midi_urid();
-            input_buffer.clear();
-            for port in state.midi_ins.iter() {
-                let mut atom = ::livi::event::LV2AtomSequence::new(
-                    &features,
-                    scope.n_frames() as usize
-                );
-                for event in port.iter(scope) {
-                    match event.bytes.len() {
-                        3 => atom.push_midi_event::<3>(
-                            event.time as i64,
-                            urid,
-                            &event.bytes[0..3]
-                        ).unwrap(),
-                        _ => {}
-                    }
-                }
-                input_buffer.push(atom);
-            }
-            let mut outputs = vec![];
-            for _ in state.midi_outs.iter() {
-                outputs.push(::livi::event::LV2AtomSequence::new(
-                    features,
-                    scope.n_frames() as usize
-                ));
-            }
-            let ports = ::livi::EmptyPortConnections::new()
-                .with_atom_sequence_inputs(input_buffer.iter())
-                .with_atom_sequence_outputs(outputs.iter_mut())
-                .with_audio_inputs(state.audio_ins.iter().map(|o|o.as_slice(scope)))
-                .with_audio_outputs(state.audio_outs.iter_mut().map(|o|o.as_mut_slice(scope)));
-            unsafe {
-                instance.run(scope.n_frames() as usize, ports).unwrap()
-            };
-        },
-        _ => todo!("only lv2 is supported")
-    }
-    Control::Continue
-});
-
-    //fn jack_from_lv2 (name: &str, plugin: &::livi::Plugin) -> Usually<Jack> {
-        //let counts = plugin.port_counts();
-        //let mut jack = Jack::new(name)?;
-        //for i in 0..counts.atom_sequence_inputs {
-            //jack = jack.midi_in(&format!("midi-in-{i}"))
-        //}
-        //for i in 0..counts.atom_sequence_outputs {
-            //jack = jack.midi_out(&format!("midi-out-{i}"));
-        //}
-        //for i in 0..counts.audio_inputs {
-            //jack = jack.audio_in(&format!("audio-in-{i}"));
-        //}
-        //for i in 0..counts.audio_outputs {
-            //jack = jack.audio_out(&format!("audio-out-{i}"));
-        //}
-        //Ok(jack)
-    //}
-
-impl Plugin {
-    /// Create a plugin host device.
-    pub fn new (
-        jack: &Jack,
-        name: &str,
-    ) -> Usually<Self> {
-        Ok(Self {
-            //_engine:    Default::default(),
-            jack:       jack.clone(),
-            name:       name.into(),
-            path:       None,
-            plugin:     None,
-            selected:   0,
-            mapping:    false,
-            audio_ins:  vec![],
-            audio_outs: vec![],
-            midi_ins:   vec![],
-            midi_outs:  vec![],
-            //ports:      JackPorts::default()
-        })
-    }
-}
-impl Content<TuiOut> for Plugin {
-    fn render (&self, to: &mut TuiOut) {
-        let area = to.area();
-        let [x, y, _, height] = area;
-        let mut width = 20u16;
-        match &self.plugin {
-            Some(PluginKind::LV2(LV2Plugin { port_list, instance, .. })) => {
-                let start = self.selected.saturating_sub((height as usize / 2).saturating_sub(1));
-                let end   = start + height as usize - 2;
-                //draw_box(buf, Rect { x, y, width, height });
-                for i in start..end {
-                    if let Some(port) = port_list.get(i) {
-                        let value = if let Some(value) = instance.control_input(port.index) {
-                            value
-                        } else {
-                            port.default_value
-                        };
-                        //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
-                        let label = &format!("{:25} = {value:.03}", port.name);
-                        width = width.max(label.len() as u16 + 4);
-                        let style = if i == self.selected {
-                            Some(Style::default().green())
-                        } else {
-                            None
-                        } ;
-                        to.blit(&label, x + 2, y + 1 + i as u16 - start as u16, style);
-                    } else {
-                        break
-                    }
-                }
-            },
-            _ => {}
-        };
-        draw_header(self, to, x, y, width);
-    }
-}
-
-fn draw_header (state: &Plugin, to: &mut TuiOut, x: u16, y: u16, w: u16) {
-    let style  = Style::default().gray();
-    let label1 = format!(" {}", state.name);
-    to.blit(&label1, x + 1, y, Some(style.white().bold()));
-    if let Some(ref path) = state.path {
-        let label2 = format!("{}…", &path[..((w as usize - 10).min(path.len()))]);
-        to.blit(&label2, x + 2 + label1.len() as u16, y, Some(style.not_dim()));
-    }
-    //Ok(Rect { x, y, width: w, height: 1 })
-}
-
-//handle!(TuiIn: |self:Plugin, from|{
-    //match from.event() {
-        //kpat!(KeyCode::Up) => {
-            //self.selected = self.selected.saturating_sub(1);
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Down) => {
-            //self.selected = (self.selected + 1).min(match &self.plugin {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
-                //_ => unimplemented!()
-            //});
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::PageUp) => {
-            //self.selected = self.selected.saturating_sub(8);
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::PageDown) => {
-            //self.selected = (self.selected + 10).min(match &self.plugin {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
-                //_ => unimplemented!()
-            //});
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Char(',')) => {
-            //match self.plugin.as_mut() {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
-                    //let index = port_list[self.selected].index;
-                    //if let Some(value) = instance.control_input(index) {
-                        //instance.set_control_input(index, value - 0.01);
-                    //}
-                //},
-                //_ => {}
-            //}
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Char('.')) => {
-            //match self.plugin.as_mut() {
-                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
-                    //let index = port_list[self.selected].index;
-                    //if let Some(value) = instance.control_input(index) {
-                        //instance.set_control_input(index, value + 0.01);
-                    //}
-                //},
-                //_ => {}
-            //}
-            //Ok(Some(true))
-        //},
-        //kpat!(KeyCode::Char('g')) => {
-            //match self.plugin {
-                ////Some(PluginKind::LV2(ref mut plugin)) => {
-                    ////plugin.ui_thread = Some(run_lv2_ui(LV2PluginUI::new()?)?);
-                ////},
-                //Some(_) => unreachable!(),
-                //None => {}
-            //}
-            //Ok(Some(true))
-        //},
-        //_ => Ok(None)
-    //}
-//});
-
-//from_atom!("plugin/lv2" => |jack: &Jack, args| -> Plugin {
-    //let mut name = String::new();
-    //let mut path = String::new();
-    //atom!(atom in args {
-        //Atom::Map(map) => {
-            //if let Some(Atom::Str(n)) = map.get(&Atom::Key(":name")) {
-                //name = String::from(*n);
-            //}
-            //if let Some(Atom::Str(p)) = map.get(&Atom::Key(":path")) {
-                //path = String::from(*p);
-            //}
-        //},
-        //_ => panic!("unexpected in lv2 '{name}'"),
-    //});
-    //Plugin::new_lv2(jack, &name, &path)
-//});

crates/device/src/sampler.rs

@@ -1,13 +1,5 @@
-#![feature(let_chains)]
+use crate::*;
 
-pub(crate) use ::tek_jack::{*, jack::*};
-pub(crate) use ::tek_midi::{*, midly::{*, live::*, num::*}};
-pub(crate) use ::tengri::{dsl::*, input::*, output::*, tui::{*, ratatui::prelude::*}};
-pub(crate) use std::sync::{Arc, RwLock, atomic::{AtomicUsize, Ordering::Relaxed}};
-pub(crate) use std::fs::File;
-pub(crate) use std::path::PathBuf;
-pub(crate) use std::error::Error;
-pub(crate) use std::ffi::OsString;
 pub(crate) use symphonia::{
     core::{
         formats::Packet,
@@ -19,7 +11,6 @@ pub(crate) use symphonia::{
     },
     default::get_codecs,
 };
-pub(crate) use ratatui::{prelude::Rect, widgets::{Widget, canvas::{Canvas, Line}}};
 
 mod sampler_api;    pub use self::sampler_api::*;
 mod sampler_audio;  pub use self::sampler_audio::*;

crates/device/src/sampler/sampler_view.rs

@@ -53,10 +53,8 @@ impl Sampler {
 
     const _EMPTY: &[(f64, f64)] = &[(0., 0.), (1., 1.), (2., 2.), (0., 2.), (2., 0.)];
 
-    pub fn view_list <'a> (
-        &'a self,
-        compact: bool,
-        editor: &MidiEditor
+    pub fn view_list <'a, T: NotePoint + NoteRange> (
+        &'a self, compact: bool, editor: &T
     ) -> impl Content<TuiOut> + 'a {
         let note_lo = editor.note_lo().load(Relaxed);
         let note_pt = editor.note_pos();

crates/device/src/sequencer.rs

@@ -0,0 +1,53 @@
+use crate::*;
+
+mod seq_clip;   pub use self::seq_clip::*;
+mod seq_launch; pub use self::seq_launch::*;
+mod seq_model;  pub use self::seq_model::*;
+mod seq_view;   pub use self::seq_view::*;
+
+#[cfg(test)] #[test] pub fn test_midi_clip () {
+    let clip = MidiClip::stop_all();
+    println!("{clip:?}");
+
+    let clip = MidiClip::default();
+    let mut clip = MidiClip::new("clip", true, 1, None, None);
+    clip.set_length(96);
+    clip.toggle_loop();
+    clip.record_event(12, midly::MidiMessage::NoteOn { key: 36.into(), vel: 100.into() });
+    assert!(clip.contains_note_on(36.into(), 6, 18));
+    assert_eq!(&clip.notes, &clip.duplicate().notes);
+
+    let clip = std::sync::Arc::new(clip);
+    assert_eq!(clip.clone(), clip);
+}
+
+#[cfg(test)] #[test] fn test_midi_play () {
+    let player = MidiPlayer::default();
+    println!("{player:?}");
+}
+
+#[cfg(test)] #[test] fn test_midi_edit () {
+    let editor = MidiEditor::default();
+    let mut editor = MidiEditor {
+        mode: PianoHorizontal::new(Some(&Arc::new(RwLock::new(MidiClip::stop_all())))),
+        size: Default::default(),
+        keys: Default::default(),
+    };
+    let _ = editor.put_note(true);
+    let _ = editor.put_note(false);
+    let _ = editor.clip_status();
+    let _ = editor.edit_status();
+    struct TestEditorHost(Option<MidiEditor>);
+    has_editor!(|self: TestEditorHost|{
+        editor = self.0;
+        editor_w = 0;
+        editor_h = 0;
+        is_editing = false;
+    });
+    let mut host = TestEditorHost(Some(editor));
+    let _ = host.editor();
+    let _ = host.editor_mut();
+    let _ = host.is_editing();
+    let _ = host.editor_w();
+    let _ = host.editor_h();
+}

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);
+    }
+}