unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-07 20:26:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor sequencer processing

Browse source
This commit is contained in:
🪞👃🪞 2024-06-29 23:29:41 +03:00
parent 2b4f28ae36
commit 82b5614040
4 changed files with 187 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

129
src/device/sequencer/mod.rs
View file

@ -4,12 +4,14 @@ mod keys;
use self::keys::*;
mod handle;
pub use self::handle::*;
mod process;
pub use self::process::*;
pub mod horizontal;
pub mod vertical;
type PhraseData = BTreeMap<u32, Vec<MidiMessage>>;
pub type PhraseData = BTreeMap<u32, Vec<MidiMessage>>;
pub struct Phrase {
pub name: String,
@ -82,7 +84,7 @@ impl Sequencer {
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 {
DynamicDevice::new(render, handle, process, Self {
name: name.into(),
midi_in: client.register_port("in", MidiIn::default())?,
midi_out: client.register_port("out", MidiOut::default())?,
@ -111,129 +113,6 @@ impl Sequencer {
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 {