mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-07 04:06:45 +01:00
572 lines
21 KiB
Rust
572 lines
21 KiB
Rust
use crate::prelude::*;
|
|
use ratatui::style::Stylize;
|
|
|
|
mod keys;
|
|
use keys::*;
|
|
|
|
pub mod horizontal;
|
|
|
|
pub mod vertical;
|
|
|
|
pub struct Sequence {
|
|
pub name: String,
|
|
pub notes: std::collections::BTreeMap<u32, Vec<::midly::MidiMessage>>
|
|
}
|
|
|
|
impl Sequence {
|
|
pub fn new (name: &str) -> Self {
|
|
Self { name: name.to_string(), notes: std::collections::BTreeMap::new() }
|
|
}
|
|
}
|
|
|
|
pub struct Sequencer {
|
|
pub name: String,
|
|
/// JACK transport handle.
|
|
transport: ::jack::Transport,
|
|
/// JACK MIDI input port that will be created.
|
|
input_port: Port<MidiIn>,
|
|
/// JACK MIDI output port that will be created.
|
|
output_port: Port<MidiOut>,
|
|
|
|
/// Holds info about tempo
|
|
timebase: Arc<Timebase>,
|
|
/// Sequencer resolution, e.g. 16 steps per beat.
|
|
/// FIXME: grid in ppm will simplify calculations
|
|
resolution: usize,
|
|
/// Steps in sequence, e.g. 64 16ths = 4 beat loop.
|
|
/// FIXME: play start / end / loop in ppm
|
|
steps: usize,
|
|
/// Sequence selector
|
|
sequence: usize,
|
|
/// Map: tick -> MIDI events at tick
|
|
pub sequences: Vec<Sequence>,
|
|
/// Red keys on piano roll.
|
|
notes_on: Vec<bool>,
|
|
|
|
/// Play sequence to output.
|
|
playing: TransportState,
|
|
/// Play input through output.
|
|
monitoring: bool,
|
|
/// Write input to sequence.
|
|
recording: bool,
|
|
/// Don't delete when recording.
|
|
overdub: bool,
|
|
|
|
/// Display mode
|
|
mode: SequencerView,
|
|
/// Range of notes to display
|
|
note_axis: (u16, u16),
|
|
/// Position of cursor within note range
|
|
note_cursor: u16,
|
|
/// Range of time steps to display
|
|
time_axis: (u16, u16),
|
|
/// Position of cursor within time range
|
|
time_cursor: u16,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum SequencerView {
|
|
Tiny,
|
|
Compact,
|
|
Horizontal,
|
|
Vertical,
|
|
}
|
|
|
|
impl Sequencer {
|
|
pub fn new (name: &str, timebase: &Arc<Timebase>) -> Usually<DynamicDevice<Self>> {
|
|
let (client, _status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
|
|
let transport = client.transport();
|
|
let state = transport.query_state()?;
|
|
DynamicDevice::new(render, handle, Self::process, Self {
|
|
name: name.into(),
|
|
input_port: client.register_port("in", MidiIn::default())?,
|
|
output_port: client.register_port("out", MidiOut::default())?,
|
|
|
|
timebase: timebase.clone(),
|
|
steps: 64,
|
|
resolution: 4,
|
|
sequence: 0,
|
|
sequences: vec![
|
|
Sequence::new(&"Phrase#01"),
|
|
Sequence::new(&"Phrase#02"),
|
|
Sequence::new(&"Phrase#03"),
|
|
Sequence::new(&"Phrase#04"),
|
|
Sequence::new(&"Phrase#05"),
|
|
Sequence::new(&"Phrase#06"),
|
|
Sequence::new(&"Phrase#07"),
|
|
Sequence::new(&"Phrase#08"),
|
|
],
|
|
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)
|
|
}
|
|
|
|
fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
|
|
|
|
// Update time
|
|
let mut sequence = &mut self.sequences[self.sequence].notes;
|
|
let transport = self.transport.query().unwrap();
|
|
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;
|
|
|
|
// Prepare output buffer
|
|
let frames = scope.n_frames() as usize;
|
|
let mut output: Vec<Option<Vec<Vec<u8>>>> = vec![None;frames];
|
|
|
|
// Read from sequence into output buffer
|
|
if self.playing == TransportState::Rolling {
|
|
let frame = transport.pos.frame() as usize;
|
|
let quant = self.timebase.fpb() 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;
|
|
::midly::live::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.input_port.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 {
|
|
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 {
|
|
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.output_port.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
|
|
}
|
|
}
|
|
|
|
fn render (s: &Sequencer, buf: &mut Buffer, mut 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 usec_per_step = s.timebase.usec_per_step(s.resolution as usize);
|
|
let steps = usecs / usec_per_step;
|
|
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
|
|
}))
|
|
}
|
|
|
|
fn draw_header (s: &Sequencer, buf: &mut Buffer, area: Rect, beat: usize) -> Usually<Rect> {
|
|
let rep = beat / s.steps;
|
|
let step = beat % s.steps;
|
|
let reps = s.steps / s.resolution;
|
|
let steps = s.steps % s.resolution;
|
|
let Rect { x, y, width, .. } = area;
|
|
let style = Style::default().gray();
|
|
let timer = format!("{rep}.{step:02} / {reps}.{steps}");
|
|
buf.set_string(x + width - 2 - timer.len() as u16, y + 1, &timer, style.bold().not_dim());
|
|
buf.set_string(x + 2, y + 1, &match s.playing {
|
|
TransportState::Rolling => format!("▶ PLAYING"),
|
|
TransportState::Starting => format!("READY ..."),
|
|
TransportState::Stopped => format!("⏹ STOPPED")
|
|
}, match s.playing {
|
|
TransportState::Stopped => style.dim().bold(),
|
|
TransportState::Starting => style.not_dim().bold(),
|
|
TransportState::Rolling => style.not_dim().white().bold()
|
|
});
|
|
buf.set_string(x, y + 2, format!("├{}┤", "-".repeat((area.width - 2).into())), style.dim());
|
|
//buf.set_string(x + 2, y + 2,
|
|
//&format!("▶ PLAY"), if s.playing {
|
|
//Style::default().green()
|
|
//} else {
|
|
//Style::default().dim()
|
|
//});
|
|
buf.set_string(x + 13, y + 1, &format!("⏺ REC"), if s.recording {
|
|
Style::default().bold().red()
|
|
} else {
|
|
Style::default().bold().dim()
|
|
});
|
|
buf.set_string(x + 20, y + 1, &format!("⏺ DUB"), if s.overdub {
|
|
Style::default().bold().yellow()
|
|
} else {
|
|
Style::default().bold().dim()
|
|
});
|
|
buf.set_string(x + 27, y + 1, &format!("⏺ MON"), if s.monitoring {
|
|
Style::default().bold().green()
|
|
} else {
|
|
Style::default().bold().dim()
|
|
});
|
|
let clips = draw_clips(s, buf, area)?;
|
|
Ok(Rect { x, y, width: area.width, height: 3 })
|
|
}
|
|
|
|
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);
|
|
buf.set_string(x + 2, y + 3 + (i as u16)*2, &label, 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: &Sequence, k: ::midly::num::u7, start: u32, end: u32) -> bool {
|
|
for (_, (_, events)) in sequence.notes.range(start..end).enumerate() {
|
|
for event in events.iter() {
|
|
match event {
|
|
::midly::MidiMessage::NoteOn {key,..} => {
|
|
if *key == k {
|
|
return true
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
pub fn handle (s: &mut Sequencer, event: &AppEvent) -> Usually<bool> {
|
|
handle_keymap(s, event, KEYMAP)
|
|
}
|
|
|
|
pub const KEYMAP: &'static [KeyBinding<Sequencer>] = keymap!(Sequencer {
|
|
[Up, NONE, "cursor_up", "move cursor up", cursor_up],
|
|
[Down, NONE, "cursor_down", "move cursor down", cursor_down],
|
|
[Left, NONE, "cursor_left", "move cursor left", cursor_left],
|
|
[Right, NONE, "cursor_right", "move cursor right", cursor_right],
|
|
[Char(']'), NONE, "cursor_inc", "increase note duration", cursor_duration_inc],
|
|
[Char('['), NONE, "cursor_dec", "decrease note duration", cursor_duration_dec],
|
|
[Char('`'), NONE, "mode_next", "Next view mode", mode_next],
|
|
[Char('+'), NONE, "zoom_in", "Zoom in", nop],
|
|
[Char('-'), NONE, "zoom_out", "Zoom out", nop],
|
|
[Char('a'), NONE, "note_add", "Add note", note_add],
|
|
[Char('z'), NONE, "note_del", "Delete note", note_del],
|
|
[CapsLock, NONE, "advance", "Toggle auto advance", nop],
|
|
[Char('w'), NONE, "rest", "Advance by note duration", nop],
|
|
[Char(' '), NONE, "toggle_play", "Toggle play/pause", toggle_play],
|
|
[Char('r'), NONE, "toggle_record", "Toggle recording", toggle_record],
|
|
[Char('d'), NONE, "toggle_overdub", "Toggle overdub", toggle_overdub],
|
|
[Char('m'), NONE, "toggle_monitor", "Toggle input monitoring", toggle_monitor],
|
|
[Char('s'), NONE, "stop_and_rewind", "Stop and rewind", stop_and_rewind],
|
|
[Char('q'), NONE, "quantize_next", "Next quantize value", quantize_next],
|
|
[Char('Q'), SHIFT, "quantize_prev", "Previous quantize value", quantize_prev],
|
|
[Char('n'), NONE, "note_axis", "Focus note axis", nop],
|
|
[Char('t'), NONE, "time_axis", "Focus time axis", nop],
|
|
[Char('v'), NONE, "variations", "Focus variation selector", nop],
|
|
[Char('s'), SHIFT, "sync", "Focus sync selector", nop],
|
|
[Char('1'), NONE, "seq_1", "Sequence 1", focus_seq(0)],
|
|
[Char('2'), NONE, "seq_2", "Sequence 2", focus_seq(1)],
|
|
[Char('3'), NONE, "seq_3", "Sequence 3", focus_seq(2)],
|
|
[Char('4'), NONE, "seq_4", "Sequence 4", focus_seq(3)],
|
|
[Char('5'), NONE, "seq_5", "Sequence 5", focus_seq(4)],
|
|
[Char('6'), NONE, "seq_6", "Sequence 6", focus_seq(5)],
|
|
[Char('7'), NONE, "seq_7", "Sequence 7", focus_seq(6)],
|
|
[Char('8'), NONE, "seq_8", "Sequence 8", focus_seq(7)],
|
|
});
|
|
|
|
const fn focus_seq (i: usize) -> impl Fn(&mut Sequencer)->Usually<bool> {
|
|
move |s: &mut Sequencer| {
|
|
s.sequence = i;
|
|
Ok(true)
|
|
}
|
|
}
|
|
|
|
fn nop (_: &mut Sequencer) -> Usually<bool> {
|
|
Ok(false)
|
|
}
|
|
fn note_add (s: &mut Sequencer) -> Usually<bool> {
|
|
let pos = s.transport.query().unwrap().pos;
|
|
let usecs = s.timebase.frame_to_usec(pos.frame() as usize);
|
|
let step = (s.time_axis.0 + s.time_cursor) as u32;
|
|
let start = (step as usize * s.timebase.ppq() / s.resolution) as u32;
|
|
let end = ((step + 1) as usize * s.timebase.ppq() / s.resolution) as u32;
|
|
let key = ::midly::num::u7::from_int_lossy((s.note_cursor + s.note_axis.0) as u8);
|
|
let note_on = ::midly::MidiMessage::NoteOn { key, vel: 100.into() };
|
|
let note_off = ::midly::MidiMessage::NoteOff { key, vel: 100.into() };
|
|
let mut sequence = &mut s.sequences[s.sequence].notes;
|
|
if sequence.contains_key(&start) {
|
|
sequence.get_mut(&start).unwrap().push(note_on.clone());
|
|
} else {
|
|
sequence.insert(start, vec![note_on]);
|
|
}
|
|
if sequence.contains_key(&end) {
|
|
sequence.get_mut(&end).unwrap().push(note_off.clone());
|
|
} else {
|
|
sequence.insert(end, vec![note_off]);
|
|
};
|
|
Ok(true)
|
|
}
|
|
fn note_del (_: &mut Sequencer) -> Usually<bool> {
|
|
Ok(true)
|
|
}
|
|
fn time_cursor_inc (s: &mut Sequencer) -> Usually<bool> {
|
|
let time = s.time_axis.1 - s.time_axis.0;
|
|
s.time_cursor = ((time + s.time_cursor) + 1) % time;
|
|
Ok(true)
|
|
}
|
|
fn time_cursor_dec (s: &mut Sequencer) -> Usually<bool> {
|
|
let time = s.time_axis.1 - s.time_axis.0;
|
|
s.time_cursor = ((time + s.time_cursor) - 1) % time;
|
|
Ok(true)
|
|
}
|
|
fn note_cursor_inc (s: &mut Sequencer) -> Usually<bool> {
|
|
let note = s.note_axis.1 - s.note_axis.0;
|
|
s.note_cursor = ((note + s.note_cursor) + 1) % note;
|
|
Ok(true)
|
|
}
|
|
fn note_cursor_dec (s: &mut Sequencer) -> Usually<bool> {
|
|
let note = s.note_axis.1 - s.note_axis.0;
|
|
s.note_cursor = ((note + s.note_cursor) - 1) % note;
|
|
Ok(true)
|
|
}
|
|
fn cursor_up (s: &mut Sequencer) -> Usually<bool> {
|
|
match s.mode {
|
|
SequencerView::Vertical => time_cursor_dec(s),
|
|
SequencerView::Horizontal => note_cursor_dec(s),
|
|
_ => Ok(false)
|
|
};
|
|
Ok(true)
|
|
}
|
|
fn cursor_down (s: &mut Sequencer) -> Usually<bool> {
|
|
match s.mode {
|
|
SequencerView::Vertical => time_cursor_inc(s),
|
|
SequencerView::Horizontal => note_cursor_inc(s),
|
|
_ => Ok(false)
|
|
};
|
|
Ok(true)
|
|
}
|
|
fn cursor_left (s: &mut Sequencer) -> Usually<bool> {
|
|
match s.mode {
|
|
SequencerView::Vertical => note_cursor_dec(s),
|
|
SequencerView::Horizontal => time_cursor_dec(s),
|
|
_ => Ok(false)
|
|
};
|
|
Ok(true)
|
|
}
|
|
fn cursor_right (s: &mut Sequencer) -> Usually<bool> {
|
|
match s.mode {
|
|
SequencerView::Vertical => note_cursor_inc(s),
|
|
SequencerView::Horizontal => time_cursor_inc(s),
|
|
_ => Ok(false)
|
|
};
|
|
Ok(true)
|
|
}
|
|
fn cursor_duration_inc (_: &mut Sequencer) -> Usually<bool> {
|
|
//s.cursor.2 = s.cursor.2 + 1
|
|
Ok(true)
|
|
}
|
|
fn cursor_duration_dec (_: &mut Sequencer) -> Usually<bool> {
|
|
//if s.cursor.2 > 0 { s.cursor.2 = s.cursor.2 - 1 }
|
|
Ok(true)
|
|
}
|
|
fn mode_next (s: &mut Sequencer) -> Usually<bool> {
|
|
s.mode = s.mode.next();
|
|
Ok(true)
|
|
}
|
|
impl SequencerView {
|
|
fn next (&self) -> Self {
|
|
match self {
|
|
Self::Horizontal => Self::Vertical,
|
|
Self::Vertical => Self::Tiny,
|
|
Self::Tiny => Self::Horizontal,
|
|
_ => self.clone()
|
|
}
|
|
}
|
|
}
|
|
fn stop_and_rewind (s: &mut Sequencer) -> Usually<bool> {
|
|
s.transport.stop()?;
|
|
s.transport.locate(0)?;
|
|
s.playing = TransportState::Stopped;
|
|
Ok(true)
|
|
}
|
|
fn toggle_play (s: &mut Sequencer) -> Usually<bool> {
|
|
s.playing = match s.playing {
|
|
TransportState::Stopped => {
|
|
s.transport.start()?;
|
|
TransportState::Starting
|
|
},
|
|
_ => {
|
|
s.transport.stop()?;
|
|
s.transport.locate(0)?;
|
|
TransportState::Stopped
|
|
},
|
|
};
|
|
Ok(true)
|
|
}
|
|
fn toggle_record (s: &mut Sequencer) -> Usually<bool> {
|
|
s.recording = !s.recording;
|
|
Ok(true)
|
|
}
|
|
fn toggle_overdub (s: &mut Sequencer) -> Usually<bool> {
|
|
s.overdub = !s.overdub;
|
|
Ok(true)
|
|
}
|
|
fn toggle_monitor (s: &mut Sequencer) -> Usually<bool> {
|
|
s.monitoring = !s.monitoring;
|
|
Ok(true)
|
|
}
|
|
fn quantize_next (s: &mut Sequencer) -> Usually<bool> {
|
|
if s.resolution < 64 {
|
|
s.resolution = s.resolution * 2;
|
|
}
|
|
Ok(true)
|
|
}
|
|
fn quantize_prev (s: &mut Sequencer) -> Usually<bool> {
|
|
if s.resolution > 1 {
|
|
s.resolution = s.resolution / 2;
|
|
}
|
|
Ok(true)
|
|
}
|
|
|
|
#[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.fps());
|
|
println!("B/S = {:.03}", s.bps());
|
|
println!("F/B = {:.03}", s.fpb());
|
|
println!("T/B = {:.03}", s.tpb());
|
|
println!("F/T = {:.03}", s.fpt());
|
|
println!("F/L = {:.03}", s.fpl());
|
|
println!("T/L = {:.03}", s.tpl());
|
|
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(())
|
|
}
|
|
}
|
|
|
|
impl DevicePorts for Sequencer {
|
|
fn midi_ins (&self) -> Usually<Vec<String>> {
|
|
Ok(vec!["in".into()])
|
|
}
|
|
fn midi_outs (&self) -> Usually<Vec<String>> {
|
|
Ok(vec!["out".into()])
|
|
}
|
|
}
|