wip: modularize once again

midi/src/lib.rs

@@ -0,0 +1,43 @@
+pub(crate) use ::tek_tui::{*, tek_input::*, tek_output::*, crossterm::event::KeyCode};
+pub(crate) use ::tek_jack::*;
+
+mod midi_pool;   pub(crate) use midi_pool::*;
+mod midi_clip;   pub(crate) use midi_clip::*;
+mod midi_launch; pub(crate) use midi_launch::*;
+mod midi_player; pub(crate) use midi_player::*;
+mod midi_in;     pub(crate) use midi_in::*;
+mod midi_out;    pub(crate) use midi_out::*;
+
+mod midi_note;   pub(crate) use midi_note::*;
+mod midi_range;  pub(crate) use midi_range::*;
+mod midi_point;  pub(crate) use midi_point::*;
+mod midi_view;   pub(crate) use midi_view::*;
+mod midi_editor; pub(crate) use midi_editor::*;
+
+/// Add "all notes off" to the start of a buffer.
+pub fn all_notes_off (output: &mut [Vec<Vec<u8>>]) {
+    let mut buf = vec![];
+    let msg = MidiMessage::Controller { controller: 123.into(), value: 0.into() };
+    let evt = LiveEvent::Midi { channel: 0.into(), message: msg };
+    evt.write(&mut buf).unwrap();
+    output[0].push(buf);
+}
+
+/// Return boxed iterator of MIDI events
+pub fn parse_midi_input (input: MidiIter) -> Box<dyn Iterator<Item=(usize, LiveEvent, &[u8])> + '_> {
+    Box::new(input.map(|RawMidi { time, bytes }|(
+        time as usize,
+        LiveEvent::parse(bytes).unwrap(),
+        bytes
+    )))
+}
+
+/// Update notes_in array
+pub fn update_keys (keys: &mut[bool;128], message: &MidiMessage) {
+    match message {
+        MidiMessage::NoteOn  { key, .. } => { keys[key.as_int() as usize] = true; }
+        MidiMessage::NoteOff { key, .. } => { keys[key.as_int() as usize] = false; },
+        _ => {}
+    }
+}
+

midi/src/midi_clip.rs

@@ -0,0 +1,109 @@
+use crate::*;
+
+pub trait HasMidiClip {
+    fn phrase (&self) -> &Arc<RwLock<MidiClip>>;
+}
+
+#[macro_export] macro_rules! has_phrase {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasMidiClip for $Struct $(<$($L),*$($T),*>)? {
+            fn phrase (&$self) -> &Arc<RwLock<MidiClip>> { &$cb }
+        }
+    }
+}
+
+/// A MIDI sequence.
+#[derive(Debug, Clone)]
+pub struct MidiClip {
+    pub uuid:        uuid::Uuid,
+    /// Name of phrase
+    pub name:        Arc<str>,
+    /// Temporal resolution in pulses per quarter note
+    pub ppq:         usize,
+    /// Length of phrase in pulses
+    pub length:      usize,
+    /// Notes in phrase
+    pub notes:       MidiData,
+    /// Whether to loop the phrase 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 phrase
+    pub color:       ItemPalette,
+}
+
+/// 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<ItemPalette>,
+    ) -> 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(ItemPalette::random)
+        }
+    }
+    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 phrase 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
+    }
+}
+
+impl Default for MidiClip {
+    fn default () -> Self {
+        Self::new(
+            "Stop",
+            false,
+            1,
+            Some(vec![vec![MidiMessage::Controller {
+                controller: 123.into(),
+                value: 0.into()
+            }]]),
+            Some(ItemColor::from(Color::Rgb(32, 32, 32)).into())
+        )
+    }
+}
+
+impl PartialEq for MidiClip {
+    fn eq (&self, other: &Self) -> bool {
+        self.uuid == other.uuid
+    }
+}
+
+impl Eq for MidiClip {}

midi/src/midi_editor.rs

@@ -0,0 +1,245 @@
+use crate::*;
+use KeyCode::{Char, Up, Down, Left, Right, Enter};
+use MidiEditCommand::*;
+
+pub trait HasEditor {
+    fn editor (&self) -> &MidiEditor;
+}
+#[macro_export] macro_rules! has_editor {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasEditor for $Struct $(<$($L),*$($T),*>)? {
+            fn editor (&$self) -> &MidiEditor { &$cb }
+        }
+    }
+}
+
+/// Contains state for viewing and editing a phrase
+pub struct MidiEditor {
+    pub mode: PianoHorizontal,
+    pub size: Measure<TuiOut>
+}
+
+from!(|phrase: &Arc<RwLock<MidiClip>>|MidiEditor = {
+    let mut model = Self::from(Some(phrase.clone()));
+    model.redraw();
+    model
+});
+
+from!(|phrase: Option<Arc<RwLock<MidiClip>>>|MidiEditor = {
+    let mut model = Self::default();
+    *model.phrase_mut() = phrase;
+    model.redraw();
+    model
+});
+
+impl Default for MidiEditor {
+    fn default () -> Self {
+        let mut mode = PianoHorizontal::new(None);
+        mode.redraw();
+        Self { mode, size: Measure::new() }
+    }
+}
+
+has_size!(<TuiOut>|self: MidiEditor|&self.size);
+
+render!(TuiOut: (self: MidiEditor) => {
+    self.autoscroll();
+    self.autozoom();
+    Fill::xy(Bsp::b(&self.size, &self.mode))
+});
+
+impl TimeRange for MidiEditor {
+    fn time_len   (&self) -> &AtomicUsize { self.mode.time_len()   }
+    fn time_zoom  (&self) -> &AtomicUsize { self.mode.time_zoom()  }
+    fn time_lock  (&self) -> &AtomicBool  { self.mode.time_lock()  }
+    fn time_start (&self) -> &AtomicUsize { self.mode.time_start() }
+    fn time_axis  (&self) -> &AtomicUsize { self.mode.time_axis()  }
+}
+
+impl NoteRange for MidiEditor {
+    fn note_lo    (&self) -> &AtomicUsize { self.mode.note_lo()    }
+    fn note_axis  (&self) -> &AtomicUsize { self.mode.note_axis()  }
+}
+
+impl NotePoint for MidiEditor {
+    fn note_len (&self) -> usize { self.mode.note_len() }
+    fn set_note_len (&self, x: usize) { self.mode.set_note_len(x) }
+    fn note_point (&self) -> usize { self.mode.note_point() }
+    fn set_note_point (&self, x: usize) { self.mode.set_note_point(x) }
+}
+
+impl TimePoint for MidiEditor {
+    fn time_point (&self) -> usize { self.mode.time_point() }
+    fn set_time_point (&self, x: usize) { self.mode.set_time_point(x) }
+}
+
+impl MidiViewer for MidiEditor {
+    fn buffer_size (&self, phrase: &MidiClip) -> (usize, usize) {
+        self.mode.buffer_size(phrase)
+    }
+    fn redraw (&self) {
+        self.mode.redraw()
+    }
+    fn phrase (&self) -> &Option<Arc<RwLock<MidiClip>>> {
+        self.mode.phrase()
+    }
+    fn phrase_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> {
+        self.mode.phrase_mut()
+    }
+    fn set_phrase (&mut self, phrase: Option<&Arc<RwLock<MidiClip>>>) {
+        self.mode.set_phrase(phrase)
+    }
+}
+
+impl MidiEditor {
+    /// Put note at current position
+    pub fn put_note (&mut self, advance: bool) {
+        let mut redraw = false;
+        if let Some(phrase) = self.phrase() {
+            let mut phrase = phrase.write().unwrap();
+            let note_start = self.time_point();
+            let note_point = self.note_point();
+            let note_len   = self.note_len();
+            let note_end   = note_start + (note_len.saturating_sub(1));
+            let key: u7    = u7::from(note_point as u8);
+            let vel: u7    = 100.into();
+            let length     = phrase.length;
+            let note_end   = note_end % length;
+            let note_on = MidiMessage::NoteOn { key, vel };
+            if !phrase.notes[note_start].iter().any(|msg|*msg == note_on) {
+                phrase.notes[note_start].push(note_on);
+            }
+            let note_off = MidiMessage::NoteOff { key, vel };
+            if !phrase.notes[note_end].iter().any(|msg|*msg == note_off) {
+                phrase.notes[note_end].push(note_off);
+            }
+            if advance {
+                self.set_time_point(note_end);
+            }
+            redraw = true;
+        }
+        if redraw {
+            self.mode.redraw();
+        }
+    }
+
+    pub fn clip_status (&self) -> impl Content<TuiOut> + '_ {
+        let (color, name, length, looped) = if let Some(phrase) = self.phrase().as_ref().map(|p|p.read().unwrap()) {
+            (phrase.color, phrase.name.clone(), phrase.length, phrase.looped)
+        } else {
+            (ItemPalette::from(TuiTheme::g(64)), String::new().into(), 0, false)
+        };
+        row!(
+            FieldV(color, "Edit", format!("{name} ({length})")),
+            FieldV(color, "Loop", looped.to_string())
+        )
+    }
+
+    pub fn edit_status (&self) -> impl Content<TuiOut> + '_ {
+        let (color, name, length, looped) = if let Some(phrase) = self.phrase().as_ref().map(|p|p.read().unwrap()) {
+            (phrase.color, phrase.name.clone(), phrase.length, phrase.looped)
+        } else {
+            (ItemPalette::from(TuiTheme::g(64)), String::new().into(), 0, false)
+        };
+        let time_point = self.time_point();
+        let time_start = self.time_start();
+        let time_end   = self.time_end();
+        let time_axis  = self.time_axis().get();
+        let time_zoom  = self.time_zoom().get();
+        let time_lock  = if self.time_lock().get() { "[lock]" } else { "      " };
+        let time_field = FieldV(color, "Time", format!("{length}/{time_zoom}+{time_point} {time_lock}"));
+
+        let note_point = format!("{:>3}", self.note_point());
+        let note_name  = format!("{:4}",  Note::pitch_to_name(self.note_point()));
+        let note_len   = format!("{:>4}", self.note_len());;;;
+        let note_field = FieldV(color, "Note", format!("{note_name} {note_point} {note_len}"));
+        Bsp::e(time_field, note_field,)
+    }
+}
+
+impl std::fmt::Debug for MidiEditor {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("MidiEditor")
+            .field("mode", &self.mode)
+            .finish()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum MidiEditCommand {
+    // TODO: 1-9 seek markers that by default start every 8th of the phrase
+    AppendNote,
+    PutNote,
+    SetNoteCursor(usize),
+    SetNoteLength(usize),
+    SetNoteScroll(usize),
+    SetTimeCursor(usize),
+    SetTimeScroll(usize),
+    SetTimeZoom(usize),
+    SetTimeLock(bool),
+    Show(Option<Arc<RwLock<MidiClip>>>),
+}
+
+handle!(TuiIn: |self: MidiEditor, input|MidiEditCommand::execute_with_state(self, input.event()));
+
+keymap!(KEYS_MIDI_EDITOR = |s: MidiEditor, _input: Event| MidiEditCommand {
+    key(Up)               => SetNoteCursor(s.note_point() + 1),
+    key(Char('w'))        => SetNoteCursor(s.note_point() + 1),
+    key(Down)             => SetNoteCursor(s.note_point().saturating_sub(1)),
+    key(Char('s'))        => SetNoteCursor(s.note_point().saturating_sub(1)),
+    key(Left)             => SetTimeCursor(s.time_point().saturating_sub(s.note_len())),
+    key(Char('a'))        => SetTimeCursor(s.time_point().saturating_sub(s.note_len())),
+    key(Right)            => SetTimeCursor((s.time_point() + s.note_len()) % s.phrase_length()),
+    ctrl(alt(key(Up)))    => SetNoteScroll(s.note_point() + 3),
+    ctrl(alt(key(Down)))  => SetNoteScroll(s.note_point().saturating_sub(3)),
+    ctrl(alt(key(Left)))  => SetTimeScroll(s.time_point().saturating_sub(s.time_zoom().get())),
+    ctrl(alt(key(Right))) => SetTimeScroll((s.time_point() + s.time_zoom().get()) % s.phrase_length()),
+    ctrl(key(Up))         => SetNoteScroll(s.note_lo().get() + 1),
+    ctrl(key(Down))       => SetNoteScroll(s.note_lo().get().saturating_sub(1)),
+    ctrl(key(Left))       => SetTimeScroll(s.time_start().get().saturating_sub(s.note_len())),
+    ctrl(key(Right))      => SetTimeScroll(s.time_start().get() + s.note_len()),
+    alt(key(Up))          => SetNoteCursor(s.note_point() + 3),
+    alt(key(Down))        => SetNoteCursor(s.note_point().saturating_sub(3)),
+    alt(key(Left))        => SetTimeCursor(s.time_point().saturating_sub(s.time_zoom().get())),
+    alt(key(Right))       => SetTimeCursor((s.time_point() + s.time_zoom().get()) % s.phrase_length()),
+    key(Char('d'))        => SetTimeCursor((s.time_point() + s.note_len()) % s.phrase_length()),
+    key(Char('z'))        => SetTimeLock(!s.time_lock().get()),
+    key(Char('-'))        => SetTimeZoom(if s.time_lock().get() { s.time_zoom().get() } else { Note::next(s.time_zoom().get()) }),
+    key(Char('_'))        => SetTimeZoom(if s.time_lock().get() { s.time_zoom().get() } else { Note::next(s.time_zoom().get()) }),
+    key(Char('='))        => SetTimeZoom(if s.time_lock().get() { s.time_zoom().get() } else { Note::prev(s.time_zoom().get()) }),
+    key(Char('+'))        => SetTimeZoom(if s.time_lock().get() { s.time_zoom().get() } else { Note::prev(s.time_zoom().get()) }),
+    key(Enter)            => PutNote,
+    ctrl(key(Enter))      => AppendNote,
+    key(Char(','))        => SetNoteLength(Note::prev(s.note_len())),
+    key(Char('.'))        => SetNoteLength(Note::next(s.note_len())),
+    key(Char('<'))        => SetNoteLength(Note::prev(s.note_len())),
+    key(Char('>'))        => SetNoteLength(Note::next(s.note_len())),
+    //// TODO: kpat!(Char('/')) => // toggle 3plet
+    //// TODO: kpat!(Char('?')) => // toggle dotted
+});
+
+impl MidiEditor {
+    fn phrase_length (&self) -> usize {
+        self.phrase().as_ref().map(|p|p.read().unwrap().length).unwrap_or(1)
+    }
+}
+
+impl Command<MidiEditor> for MidiEditCommand {
+    fn execute (self, state: &mut MidiEditor) -> Perhaps<Self> {
+        use MidiEditCommand::*;
+        match self {
+            Show(phrase)        => { state.set_phrase(phrase.as_ref());   },
+            PutNote             => { state.put_note(false);               },
+            AppendNote          => { state.put_note(true);                },
+            SetTimeZoom(x)      => { state.time_zoom().set(x); state.redraw(); },
+            SetTimeLock(x)      => { state.time_lock().set(x);            },
+            SetTimeScroll(x)    => { state.time_start().set(x);           },
+            SetNoteScroll(x)    => { state.note_lo().set(x.min(127));     },
+            SetNoteLength(x)    => { state.set_note_len(x);               },
+            SetTimeCursor(x)    => { state.set_time_point(x);             },
+            SetNoteCursor(note) => { state.set_note_point(note.min(127)); },
+            _ => todo!("{:?}", self)
+        }
+        Ok(None)
+    }
+}

midi/src/midi_in.rs

@@ -0,0 +1,91 @@
+use crate::*;
+
+/// Trait for thing that may receive MIDI.
+pub trait HasMidiIns {
+    fn midi_ins (&self) -> &Vec<Port<MidiIn>>;
+    fn midi_ins_mut (&mut self) -> &mut Vec<Port<MidiIn>>;
+    fn has_midi_ins (&self) -> bool {
+        !self.midi_ins().is_empty()
+    }
+}
+
+pub trait MidiRecordApi: HasClock + HasPlayPhrase + 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 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.iter(scope)) {
+                if let LiveEvent::Midi { message, .. } = event {
+                    if monitoring {
+                        midi_buf[sample].push(bytes.to_vec());
+                    }
+                    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_phrase().clone() {
+            self.record_clip(scope, started, clip, midi_buf);
+        }
+        if let Some((start_at, phrase)) = &self.next_phrase() {
+            self.record_next();
+        }
+    }
+    fn record_clip (
+        &mut self,
+        scope:    &ProcessScope,
+        started:  Moment,
+        phrase:   &Option<Arc<RwLock<MidiClip>>>,
+        midi_buf: &mut Vec<Vec<Vec<u8>>>
+    ) {
+        if let Some(phrase) = phrase {
+            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 phrase = phrase.write().unwrap();
+            let length     = phrase.length;
+            for input in self.midi_ins_mut().iter() {
+                for (sample, event, bytes) in parse_midi_input(input.iter(scope)) {
+                    if let LiveEvent::Midi { message, .. } = event {
+                        phrase.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
+    }
+    fn overdub (&self) -> bool;
+    fn overdub_mut (&mut self) -> &mut bool;
+    fn toggle_overdub (&mut self) {
+        *self.overdub_mut() = !self.overdub();
+    }
+}

midi/src/midi_launch.rs

@@ -0,0 +1,35 @@
+use crate::*;
+
+pub trait HasPlayPhrase: HasClock {
+    fn reset (&self) -> bool;
+    fn reset_mut (&mut self) -> &mut bool;
+    fn play_phrase (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+    fn play_phrase_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+    fn next_phrase (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+    fn next_phrase_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
+    fn pulses_since_start (&self) -> Option<f64> {
+        if let Some((started, Some(_))) = self.play_phrase().as_ref() {
+            let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
+            Some(elapsed)
+        } else {
+            None
+        }
+    }
+    fn pulses_since_start_looped (&self) -> Option<(f64, f64)> {
+        if let Some((started, Some(phrase))) = self.play_phrase().as_ref() {
+            let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
+            let length  = phrase.read().unwrap().length.max(1); // prevent div0 on empty phrase
+            let times   = (elapsed as usize / length) as f64;
+            let elapsed = (elapsed as usize % length) as f64;
+            Some((times, elapsed))
+        } else {
+            None
+        }
+    }
+    fn enqueue_next (&mut self, phrase: Option<&Arc<RwLock<MidiClip>>>) {
+        let start   = self.clock().next_launch_pulse() as f64;
+        let instant = Moment::from_pulse(self.clock().timebase(), start);
+        *self.next_phrase_mut() = Some((instant, phrase.cloned()));
+        *self.reset_mut() = true;
+    }
+}

midi/src/midi_note.rs

@@ -0,0 +1,56 @@
+use crate::*;
+
+pub struct Note;
+
+impl Note {
+    pub const NAMES: [&str; 128] = [
+        "C0", "C#0", "D0", "D#0", "E0", "F0", "F#0", "G0", "G#0", "A0", "A#0", "B0",
+        "C1", "C#1", "D1", "D#1", "E1", "F1", "F#1", "G1", "G#1", "A1", "A#1", "B1",
+        "C2", "C#2", "D2", "D#2", "E2", "F2", "F#2", "G2", "G#2", "A2", "A#2", "B2",
+        "C3", "C#3", "D3", "D#3", "E3", "F3", "F#3", "G3", "G#3", "A3", "A#3", "B3",
+        "C4", "C#4", "D4", "D#4", "E4", "F4", "F#4", "G4", "G#4", "A4", "A#4", "B4",
+        "C5", "C#5", "D5", "D#5", "E5", "F5", "F#5", "G5", "G#5", "A5", "A#5", "B5",
+        "C6", "C#6", "D6", "D#6", "E6", "F6", "F#6", "G6", "G#6", "A6", "A#6", "B6",
+        "C7", "C#7", "D7", "D#7", "E7", "F7", "F#7", "G7", "G#7", "A7", "A#7", "B7",
+        "C8", "C#8", "D8", "D#8", "E8", "F8", "F#8", "G8", "G#8", "A8", "A#8", "B8",
+        "C9", "C#9", "D9", "D#9", "E9", "F9", "F#9", "G9", "G#9", "A9", "A#9", "B9",
+        "C10", "C#10", "D10", "D#10", "E10", "F10", "F#10", "G10",
+    ];
+    pub fn pitch_to_name (n: usize) -> &'static str {
+        if n > 127 {
+            panic!("to_note_name({n}): must be 0-127");
+        }
+        Self::NAMES[n]
+    }
+
+    /// (pulses, name), assuming 96 PPQ
+    pub const DURATIONS: [(usize, &str);26] = [
+        (1,    "1/384"), (2,    "1/192"),
+        (3,    "1/128"), (4,    "1/96"),
+        (6,    "1/64"),  (8,    "1/48"),
+        (12,   "1/32"),  (16,   "1/24"),
+        (24,   "1/16"),  (32,   "1/12"),
+        (48,   "1/8"),   (64,   "1/6"),
+        (96,   "1/4"),   (128,  "1/3"),
+        (192,  "1/2"),   (256,  "2/3"),
+        (384,  "1/1"),   (512,  "4/3"),
+        (576,  "3/2"),   (768,  "2/1"),
+        (1152, "3/1"),   (1536, "4/1"),
+        (2304, "6/1"),   (3072, "8/1"),
+        (3456, "9/1"),   (6144, "16/1"),
+    ];
+    /// Returns the next shorter length
+    pub fn prev (pulses: usize) -> usize {
+        for (length, _) in Self::DURATIONS.iter().rev() { if *length < pulses { return *length } }
+        pulses
+    }
+    /// Returns the next longer length
+    pub fn next (pulses: usize) -> usize {
+        for (length, _) in Self::DURATIONS.iter() { if *length > pulses { return *length } }
+        pulses
+    }
+    pub fn pulses_to_name (pulses: usize) -> &'static str {
+        for (length, name) in Self::DURATIONS.iter() { if *length == pulses { return name } }
+        ""
+    }
+}

midi/src/midi_out.rs

@@ -0,0 +1,160 @@
+use crate::*;
+
+/// Trait for thing that may output MIDI.
+pub trait HasMidiOuts {
+    fn midi_outs (&self) -> &Vec<Port<MidiOut>>;
+    fn midi_outs_mut (&mut self) -> &mut Vec<Port<MidiOut>>;
+    fn has_midi_outs (&self) -> bool {
+        !self.midi_outs().is_empty()
+    }
+    /// Buffer for serializing a MIDI event. FIXME rename
+    fn midi_note (&mut self) -> &mut Vec<u8>;
+}
+
+pub trait MidiPlaybackApi: HasPlayPhrase + 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
+    ) {
+        for frame in &mut out[0..scope.n_frames() as usize] {
+            frame.clear();
+        }
+        if reset {
+            all_notes_off(out);
+        }
+    }
+
+    /// Output notes from phrase 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 phrase is playing, write a chunk of MIDI events from it to the output buffer.
+        // If no phrase is playing, prepare for switchover immediately.
+        self.play_phrase().as_ref().map_or(true, |(started, phrase)|{
+            self.play_chunk(scope, note_buf, out, started, phrase)
+        })
+    }
+
+    /// Handle switchover from current to next playing phrase.
+    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, phrase)) = &self.next_phrase() {
+            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 phrase:
+            if start <= sample0.saturating_sub(sample) {
+                // Samples elapsed since phrase was supposed to start
+                let _skipped = sample0 - start;
+                // Switch over to enqueued phrase
+                let started = Moment::from_sample(self.clock().timebase(), start as f64);
+                // Launch enqueued phrase
+                *self.play_phrase_mut() = Some((started, phrase.clone()));
+                // Unset enqueuement (TODO: where to implement looping?)
+                *self.next_phrase_mut() = None;
+                // Fill in remaining ticks of chunk from next phrase.
+                self.play(scope, note_buf, out);
+            }
+        }
+    }
+
+    fn play_chunk (
+        &self,
+        scope:    &ProcessScope,
+        note_buf: &mut Vec<u8>,
+        out:      &mut [Vec<Vec<u8>>],
+        started:  &Moment,
+        phrase:   &Option<Arc<RwLock<MidiClip>>>
+    ) -> bool {
+        // First sample to populate. Greater than 0 means that the first
+        // pulse of the phrase 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 phrase 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 = phrase.as_ref().map_or(0, |p|p.read().unwrap().length);
+        for (sample, pulse) in pulses {
+            // If a next phrase is enqueued, and we're past the end of the current one,
+            // break the loop here (FIXME count pulse correctly)
+            let past_end = if phrase.is_some() { pulse >= length } else { true };
+            if self.next_phrase().is_some() && past_end {
+                return true
+            }
+            // If there's a currently playing phrase, output notes from it to buffer:
+            if let Some(ref phrase) = phrase {
+                Self::play_pulse(phrase, pulse, sample, note_buf, out, notes)
+            }
+        }
+        false
+    }
+
+    fn play_pulse (
+        phrase:   &RwLock<MidiClip>,
+        pulse:    usize,
+        sample:   usize,
+        note_buf: &mut Vec<u8>,
+        out:      &mut [Vec<Vec<u8>>],
+        notes:    &mut [bool;128]
+    ) {
+        // Source phrase from which the MIDI events will be taken.
+        let phrase = phrase.read().unwrap();
+        // Phrase with zero length is not processed
+        if phrase.length > 0 {
+            // Current pulse index in source phrase
+            let pulse = pulse % phrase.length;
+            // Output each MIDI event from phrase at appropriate frames of output buffer:
+            for message in phrase.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.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:?}");
+                });
+            }
+        }
+    }
+}

midi/src/midi_player.rs

@@ -0,0 +1,280 @@
+use crate::*;
+
+pub trait MidiPlayerApi: MidiRecordApi + MidiPlaybackApi + Send + Sync {}
+
+impl MidiPlayerApi for MidiPlayer {}
+
+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 }
+        }
+    }
+}
+
+/// Contains state for playing a phrase
+pub struct MidiPlayer {
+    /// State of clock and playhead
+    pub(crate) clock:       Clock,
+    /// Start time and phrase being played
+    pub(crate) play_phrase: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Start time and next phrase
+    pub(crate) next_phrase: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Play input through output.
+    pub(crate) monitoring:  bool,
+    /// Write input to sequence.
+    pub(crate) recording:   bool,
+    /// Overdub input to sequence.
+    pub(crate) overdub:     bool,
+    /// Send all notes off
+    pub(crate) reset:       bool, // TODO?: after Some(nframes)
+    /// Record from MIDI ports to current sequence.
+    pub midi_ins:           Vec<Port<MidiIn>>,
+    /// Play from current sequence to MIDI ports
+    pub midi_outs:          Vec<Port<MidiOut>>,
+    /// Notes currently held at input
+    pub(crate) notes_in:    Arc<RwLock<[bool; 128]>>,
+    /// Notes currently held at output
+    pub(crate) notes_out:   Arc<RwLock<[bool; 128]>>,
+    /// MIDI output buffer
+    pub note_buf:           Vec<u8>,
+}
+impl MidiPlayer {
+    pub fn new (
+        jack:      &Arc<RwLock<JackConnection>>,
+        name:      impl AsRef<str>,
+        midi_from: &[impl AsRef<str>],
+        midi_to:   &[impl AsRef<str>],
+    ) -> Usually<Self> {
+        let name     = name.as_ref();
+        let midi_in  = jack.midi_in(&format!("M/{name}"), midi_from)?;
+        let midi_out = jack.midi_out(&format!("{name}/M"), midi_to)?;
+        Ok(Self {
+            clock:       Clock::from(jack),
+            play_phrase: None,
+            next_phrase: None,
+            recording:   false,
+            monitoring:  false,
+            overdub:     false,
+
+            notes_in:    RwLock::new([false;128]).into(),
+            midi_ins:    vec![midi_in],
+            midi_outs:   vec![midi_out],
+            notes_out:   RwLock::new([false;128]).into(),
+            reset:       true,
+
+            note_buf:    vec![0;8],
+        })
+    }
+    pub fn play_status (&self) -> impl Content<TuiOut> {
+        ClipSelected::play_phrase(self)
+    }
+    pub fn next_status (&self) -> impl Content<TuiOut> {
+        ClipSelected::next_phrase(self)
+    }
+}
+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_phrase", &self.play_phrase)
+            .field("next_phrase", &self.next_phrase)
+            .finish()
+    }
+}
+from!(|clock: &Clock| MidiPlayer = Self {
+    clock:       clock.clone(),
+    midi_ins:    vec![],
+    midi_outs:   vec![],
+    note_buf:    vec![0;8],
+    reset:       true,
+    recording:   false,
+    monitoring:  false,
+    overdub:     false,
+    play_phrase: None,
+    next_phrase: None,
+    notes_in:    RwLock::new([false;128]).into(),
+    notes_out:   RwLock::new([false;128]).into(),
+});
+from!(|state: (&Clock, &Arc<RwLock<MidiClip>>)|MidiPlayer = {
+    let (clock, phrase) = state;
+    let mut model = Self::from(clock);
+    model.play_phrase = Some((Moment::zero(&clock.timebase), Some(phrase.clone())));
+    model
+});
+has_clock!(|self: MidiPlayer|&self.clock);
+
+impl HasMidiIns for MidiPlayer {
+    fn midi_ins (&self) -> &Vec<Port<MidiIn>> {
+        &self.midi_ins
+    }
+    fn midi_ins_mut (&mut self) -> &mut Vec<Port<MidiIn>> {
+        &mut self.midi_ins
+    }
+}
+
+impl HasMidiOuts for MidiPlayer {
+    fn midi_outs (&self) -> &Vec<Port<MidiOut>> {
+        &self.midi_outs
+    }
+    fn midi_outs_mut (&mut self) -> &mut Vec<Port<MidiOut>> {
+        &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 phrase 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 phrase 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 HasPlayPhrase for MidiPlayer {
+    fn reset (&self) -> bool {
+        self.reset
+    }
+    fn reset_mut (&mut self) -> &mut bool {
+        &mut self.reset
+    }
+    fn play_phrase (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.play_phrase
+    }
+    fn play_phrase_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.play_phrase
+    }
+    fn next_phrase (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.next_phrase
+    }
+    fn next_phrase_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.next_phrase
+    }
+}
+
+//#[derive(Debug)]
+//pub struct MIDIPlayer {
+    ///// Global timebase
+    //pub clock:        Arc<Clock>,
+    ///// Start time and phrase being played
+    //pub play_phrase:  Option<(Moment, Option<Arc<RwLock<Phrase>>>)>,
+    ///// Start time and next phrase
+    //pub next_phrase:  Option<(Moment, Option<Arc<RwLock<Phrase>>>)>,
+    ///// 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_inputs:  Vec<Port<MidiIn>>,
+    ///// Play from current sequence to MIDI ports
+    //pub midi_outputs: Vec<Port<MidiOut>>,
+    ///// MIDI output buffer
+    //pub midi_note:    Vec<u8>,
+    ///// MIDI output buffer
+    //pub midi_chunk:   Vec<Vec<Vec<u8>>>,
+    ///// Notes currently held at input
+    //pub notes_in:     Arc<RwLock<[bool; 128]>>,
+    ///// Notes currently held at output
+    //pub notes_out:    Arc<RwLock<[bool; 128]>>,
+//}
+
+///// Methods used primarily by the process callback
+//impl MIDIPlayer {
+    //pub fn new (
+        //jack:  &Arc<RwLock<JackConnection>>,
+        //clock: &Arc<Clock>,
+        //name:  &str
+    //) -> Usually<Self> {
+        //let jack = jack.read().unwrap();
+        //Ok(Self {
+            //clock:        clock.clone(),
+            //phrase:       None,
+            //next_phrase:  None,
+            //notes_in:     Arc::new(RwLock::new([false;128])),
+            //notes_out:    Arc::new(RwLock::new([false;128])),
+            //monitoring:   false,
+            //recording:    false,
+            //overdub:      true,
+            //reset:        true,
+            //midi_note:    Vec::with_capacity(8),
+            //midi_chunk:   vec![Vec::with_capacity(16);16384],
+            //midi_outputs: vec![
+                //jack.client().register_port(format!("{name}_out0").as_str(), MidiOut::default())?
+            //],
+            //midi_inputs:  vec![
+                //jack.client().register_port(format!("{name}_in0").as_str(), MidiIn::default())?
+            //],
+        //})
+    //}
+//}

midi/src/midi_point.rs

@@ -0,0 +1,50 @@
+use crate::*;
+
+#[derive(Debug, Clone)]
+pub struct MidiPointModel {
+    /// Time coordinate of cursor
+    pub time_point: Arc<AtomicUsize>,
+    /// Note coordinate of cursor
+    pub note_point: Arc<AtomicUsize>,
+    /// Length of note that will be inserted, in pulses
+    pub note_len:   Arc<AtomicUsize>,
+}
+
+impl Default for MidiPointModel {
+    fn default () -> Self {
+        Self {
+            time_point: Arc::new(0.into()),
+            note_point: Arc::new(36.into()),
+            note_len:   Arc::new(24.into()),
+        }
+    }
+}
+
+pub trait NotePoint {
+    fn note_len       (&self) -> usize;
+    fn set_note_len   (&self, x: usize);
+    fn note_point     (&self) -> usize;
+    fn set_note_point (&self, x: usize);
+    fn note_end (&self) -> usize { self.note_point() + self.note_len() }
+}
+
+pub trait TimePoint {
+    fn time_point     (&self) -> usize;
+    fn set_time_point (&self, x: usize);
+}
+
+pub trait MidiPoint: NotePoint + TimePoint {}
+
+impl<T: NotePoint + TimePoint> MidiPoint for T {}
+
+impl NotePoint for MidiPointModel {
+    fn note_len (&self) -> usize { self.note_len.load(Relaxed)}
+    fn set_note_len (&self, x: usize) { self.note_len.store(x, Relaxed) }
+    fn note_point (&self) -> usize { self.note_point.load(Relaxed).min(127) }
+    fn set_note_point (&self, x: usize) { self.note_point.store(x.min(127), Relaxed) }
+}
+
+impl TimePoint for MidiPointModel {
+    fn time_point (&self) -> usize { self.time_point.load(Relaxed) }
+    fn set_time_point (&self, x: usize) { self.time_point.store(x, Relaxed) }
+}

midi/src/midi_pool.rs

@@ -0,0 +1,93 @@
+use crate::*;
+
+pub trait HasPhrases {
+    fn phrases (&self) -> &Vec<Arc<RwLock<MidiClip>>>;
+    fn phrases_mut (&mut self) -> &mut Vec<Arc<RwLock<MidiClip>>>;
+}
+
+#[macro_export] macro_rules! has_phrases {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasPhrases for $Struct $(<$($L),*$($T),*>)? {
+            fn phrases (&$self) -> &Vec<Arc<RwLock<MidiClip>>> { &$cb }
+            fn phrases_mut (&mut $self) -> &mut Vec<Arc<RwLock<MidiClip>>> { &mut$cb }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum PhrasePoolCommand {
+    Add(usize, MidiClip),
+    Delete(usize),
+    Swap(usize, usize),
+    Import(usize, PathBuf),
+    Export(usize, PathBuf),
+    SetName(usize, Arc<str>),
+    SetLength(usize, usize),
+    SetColor(usize, ItemColor),
+}
+
+impl<T: HasPhrases> Command<T> for PhrasePoolCommand {
+    fn execute (self, model: &mut T) -> Perhaps<Self> {
+        use PhrasePoolCommand::*;
+        Ok(match self {
+            Add(mut index, phrase) => {
+                let phrase  = Arc::new(RwLock::new(phrase));
+                let phrases = model.phrases_mut();
+                if index >= phrases.len() {
+                    index = phrases.len();
+                    phrases.push(phrase)
+                } else {
+                    phrases.insert(index, phrase);
+                }
+                Some(Self::Delete(index))
+            },
+            Delete(index) => {
+                let phrase = model.phrases_mut().remove(index).read().unwrap().clone();
+                Some(Self::Add(index, phrase))
+            },
+            Swap(index, other) => {
+                model.phrases_mut().swap(index, other);
+                Some(Self::Swap(index, other))
+            },
+            Import(index, path) => {
+                let bytes = std::fs::read(&path)?;
+                let smf = Smf::parse(bytes.as_slice())?;
+                let mut t = 0u32;
+                let mut events = vec![];
+                for track in smf.tracks.iter() {
+                    for event in track.iter() {
+                        t += event.delta.as_int();
+                        if let TrackEventKind::Midi { channel, message } = event.kind {
+                            events.push((t, channel.as_int(), message));
+                        }
+                    }
+                }
+                let mut phrase = MidiClip::new("imported", true, t as usize + 1, None, None);
+                for event in events.iter() {
+                    phrase.notes[event.0 as usize].push(event.2);
+                }
+                Self::Add(index, phrase).execute(model)?
+            },
+            Export(_index, _path) => {
+                todo!("export phrase to midi file");
+            },
+            SetName(index, name) => {
+                let mut phrase = model.phrases()[index].write().unwrap();
+                let old_name = phrase.name.clone();
+                phrase.name = name;
+                Some(Self::SetName(index, old_name))
+            },
+            SetLength(index, length) => {
+                let mut phrase = model.phrases()[index].write().unwrap();
+                let old_len = phrase.length;
+                phrase.length = length;
+                Some(Self::SetLength(index, old_len))
+            },
+            SetColor(index, color) => {
+                let mut color = ItemPalette::from(color);
+                std::mem::swap(&mut color, &mut model.phrases()[index].write().unwrap().color);
+                Some(Self::SetColor(index, color.base))
+            },
+        })
+    }
+}

midi/src/midi_range.rs

@@ -0,0 +1,64 @@
+use crate::*;
+
+#[derive(Debug, Clone)]
+pub struct MidiRangeModel {
+    pub time_len:   Arc<AtomicUsize>,
+    /// Length of visible time axis
+    pub time_axis:  Arc<AtomicUsize>,
+    /// Earliest time displayed
+    pub time_start: Arc<AtomicUsize>,
+    /// Time step
+    pub time_zoom:  Arc<AtomicUsize>,
+    /// Auto rezoom to fit in time axis
+    pub time_lock:  Arc<AtomicBool>,
+    /// Length of visible note axis
+    pub note_axis:  Arc<AtomicUsize>,
+    // Lowest note displayed
+    pub note_lo:    Arc<AtomicUsize>,
+}
+
+from!(|data:(usize, bool)|MidiRangeModel = Self {
+    time_len:   Arc::new(0.into()),
+    note_axis:  Arc::new(0.into()),
+    note_lo:    Arc::new(0.into()),
+    time_axis:  Arc::new(0.into()),
+    time_start: Arc::new(0.into()),
+    time_zoom:  Arc::new(data.0.into()),
+    time_lock:  Arc::new(data.1.into()),
+});
+
+pub trait TimeRange {
+    fn time_len   (&self) -> &AtomicUsize;
+    fn time_zoom  (&self) -> &AtomicUsize;
+    fn time_lock  (&self) -> &AtomicBool;
+    fn time_start (&self) -> &AtomicUsize;
+    fn time_axis  (&self) -> &AtomicUsize;
+    fn time_end   (&self) -> usize {
+        self.time_start().get() + self.time_axis().get() * self.time_zoom().get()
+    }
+}
+
+pub trait NoteRange {
+    fn note_lo    (&self) -> &AtomicUsize;
+    fn note_axis  (&self) -> &AtomicUsize;
+    fn note_hi    (&self) -> usize {
+        (self.note_lo().get() + self.note_axis().get().saturating_sub(1)).min(127)
+    }
+}
+
+pub trait MidiRange: TimeRange + NoteRange {}
+
+impl<T: TimeRange + NoteRange> MidiRange for T {}
+
+impl TimeRange for MidiRangeModel {
+    fn time_len   (&self) -> &AtomicUsize { &self.time_len   }
+    fn time_zoom  (&self) -> &AtomicUsize { &self.time_zoom  }
+    fn time_lock  (&self) -> &AtomicBool  { &self.time_lock  }
+    fn time_start (&self) -> &AtomicUsize { &self.time_start }
+    fn time_axis  (&self) -> &AtomicUsize { &self.time_axis  }
+}
+
+impl NoteRange for MidiRangeModel {
+    fn note_lo    (&self) -> &AtomicUsize { &self.note_lo    }
+    fn note_axis  (&self) -> &AtomicUsize { &self.note_axis  }
+}

midi/src/midi_view.rs

@@ -0,0 +1,66 @@
+use crate::*;
+
+pub trait MidiViewer: HasSize<TuiOut> + MidiRange + MidiPoint + Debug + Send + Sync {
+    fn buffer_size (&self, phrase: &MidiClip) -> (usize, usize);
+    fn redraw (&self);
+    fn phrase (&self) -> &Option<Arc<RwLock<MidiClip>>>;
+    fn phrase_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>>;
+    fn set_phrase (&mut self, phrase: Option<&Arc<RwLock<MidiClip>>>) {
+        *self.phrase_mut() = phrase.cloned();
+        self.redraw();
+    }
+    /// Make sure cursor is within note range
+    fn autoscroll (&self) {
+        let note_point = self.note_point().min(127);
+        let note_lo    = self.note_lo().get();
+        let note_hi    = self.note_hi();
+        if note_point < note_lo {
+            self.note_lo().set(note_point);
+        } else if note_point > note_hi {
+            self.note_lo().set((note_lo + note_point).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 = Note::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 = Note::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);
+    }
+}