wip

src/device/sequencer/mod.rs

@@ -0,0 +1,407 @@
+use crate::prelude::*;
+
+mod keys;
+use self::keys::*;
+mod handle;
+pub use self::handle::*;
+
+pub mod horizontal;
+
+pub mod vertical;
+
+type PhraseData = BTreeMap<u32, Vec<MidiMessage>>;
+
+pub struct Phrase {
+    pub name:   String,
+    pub length: u32,
+    pub notes:  PhraseData,
+}
+
+impl Phrase {
+    pub fn new (name: &str, length: u32, notes: Option<PhraseData>) -> Self {
+        Self { name: name.to_string(), length, notes: notes.unwrap_or(BTreeMap::new()) }
+    }
+}
+
+pub struct Sequencer {
+    pub name:     String,
+    /// JACK transport handle.
+    transport:    ::jack::Transport,
+    /// JACK MIDI input port that will be created.
+    pub midi_in:  Port<MidiIn>,
+    /// JACK MIDI output port that will be created.
+    pub midi_out: Port<MidiOut>,
+
+    /// Holds info about tempo
+    pub timebase: Arc<Timebase>,
+    /// Steps in sequence, e.g. 64 16ths = 4 beat loop.
+    /// FIXME: play start / end / loop in ppm
+    steps:      usize,
+    /// Phrase selector
+    sequence:   usize,
+    /// Map: tick -> MIDI events at tick
+    pub sequences: Vec<Phrase>,
+    /// Red keys on piano roll.
+    notes_on:   Vec<bool>,
+
+    /// Play sequence to output.
+    pub playing:    TransportState,
+    /// Play input through output.
+    pub monitoring: bool,
+    /// Write input to sequence.
+    pub recording:  bool,
+    /// Don't delete when recording.
+    pub overdub:    bool,
+
+    /// Display mode
+    mode:        SequencerView,
+    /// Range of notes to display
+    pub note_axis:   (u16, u16),
+    /// Position of cursor within note range
+    pub note_cursor: u16,
+    /// Sequencer resolution, e.g. 16 steps per beat.
+    /// FIXME: grid in ppm will simplify calculations
+    pub resolution:  usize,
+    /// Range of time steps to display
+    pub time_axis:   (u16, u16),
+    /// Position of cursor within time range
+    pub time_cursor: u16,
+}
+
+#[derive(Debug, Clone)]
+enum SequencerView {
+    Tiny,
+    Compact,
+    Horizontal,
+    Vertical,
+}
+
+impl Sequencer {
+    pub fn new (
+        name:      &str,
+        timebase:  &Arc<Timebase>, 
+        sequences: Option<Vec<Phrase>>,
+    ) -> Usually<DynamicDevice<Self>> {
+        let (client, _status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
+        let transport = client.transport();
+        let ppq = timebase.ppq() as u32;
+        DynamicDevice::new(render, handle, Self::process, Self {
+            name:        name.into(),
+            midi_in:     client.register_port("in",  MidiIn::default())?,
+            midi_out:    client.register_port("out", MidiOut::default())?,
+
+            timebase:    timebase.clone(),
+            steps:       16,
+            resolution:  4,
+            sequence:    0,
+            sequences:   sequences.unwrap_or(vec![]),
+            notes_on:    vec![false;128],
+
+            playing:     TransportState::Starting,
+            monitoring:  true,
+            recording:   true,
+            overdub:     true,
+            transport,
+
+            mode:        SequencerView::Horizontal,
+            note_axis:   (36, 68),
+            note_cursor: 0,
+            time_axis:   (0,  64),
+            time_cursor: 0,
+        }).activate(client)
+    }
+
+    pub fn phrase <'a> (&'a self) -> Option<&'a Phrase> {
+        self.sequences.get(self.sequence)
+    }
+
+    pub fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+
+        // Prepare output buffer
+        let frames = scope.n_frames() as usize;
+        let mut output: Vec<Option<Vec<Vec<u8>>>> = vec![None;frames];
+
+        // Update time
+        let sequence = self.sequences.get_mut(self.sequence);
+        if sequence.is_none() {
+            return Control::Continue
+        }
+        let sequence  = &mut sequence.unwrap().notes;
+        let transport = self.transport.query().unwrap();
+        // If starting or stopping, send "all notes off":
+        if transport.state != self.playing {
+            output[0] = Some(vec![]);
+            if let Some(Some(frame)) = output.get_mut(0) {
+                let mut buf = vec![];
+                LiveEvent::Midi {
+                    channel: 0.into(),
+                    message: MidiMessage::Controller { controller: 123.into(), value: 0.into() }
+                }.write(&mut buf).unwrap();
+                frame.push(buf);
+            }
+        }
+        self.playing  = transport.state;
+        let pos       = &transport.pos;
+        let usecs     = self.timebase.frame_to_usec(pos.frame() as usize);
+        let steps     = usecs / self.timebase.usec_per_step(self.resolution as usize);
+        let step      = steps % self.steps;
+        let tick      = step * self.timebase.ppq() / self.resolution;
+
+        // Read from sequence into output buffer
+        if self.playing == TransportState::Rolling {
+            let frame = transport.pos.frame() as usize;
+            let quant = self.timebase.frames_per_beat() as usize * self.steps / self.resolution;
+            let ticks = self.timebase.frames_to_ticks(frame, frame + frames, quant);
+            for (time, tick) in ticks.iter() {
+                if let Some(events) = sequence.get(&(*tick as u32)) {
+                    for message in events.iter() {
+                        let mut buf = vec![];
+                        let channel = 0.into();
+                        let message = *message;
+                        LiveEvent::Midi { channel, message }.write(&mut buf).unwrap();
+                        let t = *time as usize;
+                        if output[t].is_none() {
+                            output[t] = Some(vec![]);
+                        }
+                        if let Some(Some(frame)) = output.get_mut(t) {
+                            frame.push(buf);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Read from input, write inputs to sequence and/or output buffer
+        for event in self.midi_in.iter(scope) {
+            let tick = tick as u32;
+            let msg  = midly::live::LiveEvent::parse(event.bytes).unwrap();
+            match msg {
+                midly::live::LiveEvent::Midi { channel: _, message } => match message {
+                    midly::MidiMessage::NoteOn { key, vel: _ } => {
+                        self.notes_on[key.as_int() as usize] = true;
+                        if self.monitoring {
+                            let t = event.time as usize;
+                            if output[t].is_none() {
+                                output[t] = Some(vec![]);
+                            }
+                            if let Some(Some(frame)) = output.get_mut(t) {
+                                frame.push(event.bytes.into())
+                            }
+                        }
+                        if self.recording && self.playing == TransportState::Rolling {
+                            let contains = sequence.contains_key(&tick);
+                            if contains {
+                                sequence.get_mut(&tick).unwrap().push(message.clone());
+                            } else {
+                                sequence.insert(tick, vec![message.clone()]);
+                            }
+                        }
+                    },
+                    midly::MidiMessage::NoteOff { key, vel: _ } => {
+                        self.notes_on[key.as_int() as usize] = false;
+                        if self.monitoring {
+                            let t = event.time as usize;
+                            if output[t].is_none() {
+                                output[t] = Some(vec![]);
+                            }
+                            if let Some(Some(frame)) = output.get_mut(t) {
+                                frame.push(event.bytes.into())
+                            }
+                        }
+                        if self.recording && self.playing == TransportState::Rolling {
+                            let contains = sequence.contains_key(&tick);
+                            if contains {
+                                sequence.get_mut(&tick).unwrap().push(message.clone());
+                            } else {
+                                sequence.insert(tick, vec![message.clone()]);
+                            }
+                        }
+                    },
+                    _ => {}
+                },
+                _ => {}
+            }
+        }
+
+        // Write to port from output buffer
+        // (containing notes from sequence and/or monitor)
+        let mut writer = self.midi_out.writer(scope);
+        for time in 0..scope.n_frames() {
+            if let Some(Some(frame)) = output.get_mut(time as usize) {
+                for event in frame.iter() {
+                    writer.write(&::jack::RawMidi { time, bytes: &event })
+                        .expect(&format!("{event:?}"));
+                }
+            }
+        }
+
+        Control::Continue
+    }
+}
+
+impl PortList for Sequencer {
+    fn midi_ins  (&self) -> Usually<Vec<String>> {
+        Ok(vec![self.midi_in.name()?])
+    }
+    fn midi_outs (&self) -> Usually<Vec<String>> {
+        Ok(vec![self.midi_out.name()?])
+    }
+}
+
+fn render (s: &Sequencer, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+    let Rect { x, y, width, .. } = area;
+    let (time0, time1) = s.time_axis;
+    let (note0, note1) = s.note_axis;
+    let pos    = s.transport.query().unwrap().pos;
+    let frame  = pos.frame();
+    let usecs  = s.timebase.frame_to_usec(frame as usize);
+    let ustep  = s.timebase.usec_per_step(s.resolution as usize);
+    let steps  = usecs / ustep;
+    let header = draw_header(s, buf, area, steps)?;
+    let piano  = match s.mode {
+        SequencerView::Tiny =>
+            Rect { x, y, width, height: 0 },
+        SequencerView::Compact =>
+            Rect { x, y, width, height: 0 },
+        SequencerView::Vertical => self::vertical::draw(s, buf, Rect {
+            x,
+            y: y + header.height,
+            width:  3 + note1 - note0,
+            height: 3 + time1 - time0,
+        }, steps)?,
+        SequencerView::Horizontal => self::horizontal::draw(s, buf, Rect {
+            x,
+            y: y + header.height,
+            width:  area.width.max(3 + time1 - time0),
+            height: 3 + note1 - note0,
+        }, steps)?,
+    };
+    Ok(draw_box(buf, Rect {
+        x,
+        y,
+        width:  header.width.max(piano.width),
+        height: header.height + piano.height
+    }))
+}
+
+pub fn draw_header (s: &Sequencer, buf: &mut Buffer, area: Rect, beat: usize) -> Usually<Rect> {
+    let Rect { x, y, width, .. } = area;
+    let rep   = beat / s.steps;
+    let step  = beat % s.steps;
+    let reps  = s.steps / s.resolution;
+    let steps = s.steps % s.resolution;
+    draw_timer(buf, x + width - 2, y + 1, &format!("{rep}.{step:02} / {reps}.{steps}"));
+    let style = Style::default().gray();
+    draw_play_stop(buf, x + 2, y + 1, &s.playing);
+    let separator = format!("├{}┤", "-".repeat((area.width - 2).into()));
+    separator.blit(buf, x, y + 2, Some(style.dim()));
+    draw_rec(buf, x + 13, y + 1, s.recording);
+    draw_dub(buf, x + 20, y + 1, s.overdub);
+    draw_mon(buf, x + 27, y + 1, s.monitoring);
+    let _ = draw_clips(s, buf, area)?;
+    Ok(Rect { x, y, width: area.width, height: 3 })
+}
+pub fn draw_timer (
+    buf: &mut Buffer, x: u16, y: u16, timer: &str
+) {
+    let style = Some(Style::default().gray().bold().not_dim());
+    timer.blit(buf, x - timer.len() as u16, y, style);
+}
+pub fn draw_play_stop (buf: &mut Buffer, x: u16, y: u16, state: &TransportState) {
+    let style = Style::default().gray();
+    match state {
+        TransportState::Rolling  => "▶ PLAYING",
+        TransportState::Starting => "READY ...",
+        TransportState::Stopped  => "⏹ STOPPED",
+    }.blit(buf, x, y, Some(match state {
+        TransportState::Stopped  => style.dim().bold(),
+        TransportState::Starting => style.not_dim().bold(),
+        TransportState::Rolling  => style.not_dim().white().bold()
+    }));
+}
+pub fn draw_rec (buf: &mut Buffer, x: u16, y: u16, on: bool) {
+    "⏺ REC".blit(buf, x, y, Some(if on {
+        Style::default().bold().red()
+    } else {
+        Style::default().bold().dim()
+    }))
+}
+pub fn draw_dub (buf: &mut Buffer, x: u16, y: u16, on: bool) {
+    "⏺ DUB".blit(buf, x, y, Some(if on {
+        Style::default().bold().yellow()
+    } else {
+        Style::default().bold().dim()
+    }))
+}
+pub fn draw_mon (buf: &mut Buffer, x: u16, y: u16, on: bool) {
+    "⏺ MON".blit(buf, x, y, Some(if on {
+        Style::default().bold().green()
+    } else {
+        Style::default().bold().dim()
+    }))
+}
+fn draw_clips (s: &Sequencer, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+    let Rect { x, y, .. } = area;
+    let style = Style::default().gray();
+    for (i, sequence) in s.sequences.iter().enumerate() {
+        let label = format!("▶ {}", &sequence.name);
+        label.blit(buf, x + 2, y + 3 + (i as u16)*2, Some(if i == s.sequence {
+            match s.playing {
+                TransportState::Rolling => style.white().bold(),
+                _ => style.not_dim().bold()
+            }
+        } else {
+            style.dim()
+        }));
+    }
+    Ok(Rect { x, y, width: 14, height: 14 })
+}
+pub fn contains_note_on (sequence: &Phrase, k: u7, start: u32, end: u32) -> bool {
+    for (_, (_, events)) in sequence.notes.range(start..end).enumerate() {
+        for event in events.iter() {
+            match event {
+                MidiMessage::NoteOn {key,..} => {
+                    if *key == k {
+                        return true
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    return false
+}
+
+#[cfg(test)] mod test {
+    use super::*;
+
+    #[test]
+    fn test_sequencer_output () -> Usually<()> {
+        let sequencer = Sequencer::new("test")?;
+        let mut s = sequencer.state.lock().unwrap();
+        s.rate  = Hz(48000);
+        s.tempo = Tempo(240_000);
+        println!("F/S = {:.03}", s.frames_per_second());
+        println!("B/S = {:.03}", s.beats_per_secon());
+        println!("F/B = {:.03}", s.frames_per_beat());
+        println!("T/B = {:.03}", s.ticks_per_beat());
+        println!("F/T = {:.03}", s.frames_per_tick());
+        println!("F/L = {:.03}", s.frames_per_loop());
+        println!("T/L = {:.03}", s.ticks_per_loop());
+        let fpt = s.fpt();
+        let frames_per_chunk = 240;
+        let chunk = |chunk: usize| s.frames_to_ticks(
+            chunk * frames_per_chunk,
+            (chunk + 1) * frames_per_chunk
+        );
+        //for i in 0..2000 {
+            //println!("{i} {:?}", chunk(i));
+        //}
+        assert_eq!(chunk(0), vec![(0, 0), (125, 1)]);
+        assert_eq!(chunk(1), vec![(10, 2), (135, 3)]);
+        assert_eq!(chunk(12), vec![(120, 24)]);
+        assert_eq!(chunk(412), vec![(120, 24)]);
+        assert_eq!(chunk(413), vec![(5, 25), (130, 26)]);
+        Ok(())
+    }
+}