mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 19:56:42 +01:00
refactor sequencer processing
This commit is contained in:
parent
2b4f28ae36
commit
82b5614040
4 changed files with 187 additions and 130 deletions
|
|
@ -75,7 +75,7 @@ impl Sampler {
|
|||
let mut mixed = vec![vec![0.0;scope.n_frames() as usize];channel_count];
|
||||
|
||||
// Emit next chunk of each currently playing voice,
|
||||
// removing voices that have completed playing.
|
||||
// dropping voices that have reached their ends.
|
||||
let mut voices = vec![];
|
||||
std::mem::swap(&mut voices, &mut self.voices);
|
||||
loop {
|
||||
|
|
@ -93,6 +93,11 @@ impl Sampler {
|
|||
self.voices.push(voice);
|
||||
}
|
||||
}
|
||||
|
||||
// process midi in
|
||||
// add new voices
|
||||
// emit new voices starting from midi event frames
|
||||
//
|
||||
for (i, port) in self.audio_outs.iter_mut().enumerate() {
|
||||
let buffer = &mixed[i];
|
||||
for (i, value) in port.as_mut_slice(scope).iter_mut().enumerate() {
|
||||
|
|
@ -100,9 +105,6 @@ impl Sampler {
|
|||
}
|
||||
}
|
||||
Control::Continue
|
||||
// process midi in
|
||||
// add new voices
|
||||
// emit new voices starting from midi event frames
|
||||
|
||||
//for event in self.midi_in.iter(scope) {
|
||||
//let len = 3.min(event.bytes.len());
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ pub fn render (state: &Launcher, buf: &mut Buffer, mut area: Rect) -> Usually<Re
|
|||
let mut y = y + 1;
|
||||
y = y + LauncherGridView::new(
|
||||
state, buf, Rect { x, y, width, height: 8 }, state.view.is_tracks()
|
||||
).draw()?.height;
|
||||
).draw()?.height - 1;
|
||||
y = y + draw_section_sequencer(state, buf, Rect { x, y, width, height: 8 })?.height;
|
||||
y = y + draw_section_chains(state, buf, Rect { x, y, width, height: 8 })?.height;
|
||||
area.height = y;
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
176
src/device/sequencer/process.rs
Normal file
176
src/device/sequencer/process.rs
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
use crate::prelude::*;
|
||||
use super::*;
|
||||
|
||||
pub fn process (state: &mut Sequencer, _: &Client, scope: &ProcessScope) -> Control {
|
||||
|
||||
// Get currently playing sequence
|
||||
let sequence = state.sequences.get_mut(state.sequence);
|
||||
if sequence.is_none() {
|
||||
return Control::Continue
|
||||
}
|
||||
let sequence = sequence.unwrap();
|
||||
|
||||
// Prepare output buffer and transport
|
||||
let frames = scope.n_frames() as usize;
|
||||
let mut output: Vec<Option<Vec<Vec<u8>>>> = vec![None;frames];
|
||||
let transport = state.transport.query().unwrap();
|
||||
|
||||
// If starting or stopping, send "all notes off":
|
||||
if transport.state != state.playing {
|
||||
all_notes_off(&mut output);
|
||||
}
|
||||
|
||||
// Update time
|
||||
state.playing = transport.state;
|
||||
let frame = transport.pos.frame() as usize;
|
||||
let usecs = state.timebase.frame_to_usec(frame);
|
||||
let steps = usecs / state.timebase.usec_per_step(state.resolution as usize);
|
||||
let step = steps % state.steps;
|
||||
let tick = step * state.timebase.ppq() / state.resolution;
|
||||
|
||||
// Play from sequence into output buffer
|
||||
if state.playing == TransportState::Rolling {
|
||||
play_from_sequence(
|
||||
&mut output,
|
||||
&sequence.notes,
|
||||
&state.timebase,
|
||||
state.steps,
|
||||
state.resolution,
|
||||
frame,
|
||||
frames,
|
||||
);
|
||||
}
|
||||
|
||||
// Play from input to monitor, and record into sequence.
|
||||
monitor_and_record(
|
||||
&scope,
|
||||
&mut output,
|
||||
&mut sequence.notes,
|
||||
&state.midi_in,
|
||||
&mut state.notes_on,
|
||||
state.playing,
|
||||
state.monitoring,
|
||||
state.recording,
|
||||
tick as u32
|
||||
);
|
||||
|
||||
// Write to port from output buffer
|
||||
// (containing notes from sequence and/or monitor)
|
||||
let mut writer = state.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
|
||||
}
|
||||
|
||||
type MIDIChunk = [Option<Vec<Vec<u8>>>];
|
||||
|
||||
/// Add "all notes off" to the start of a buffer.
|
||||
fn all_notes_off (output: &mut MIDIChunk) {
|
||||
output[0] = Some(vec![]);
|
||||
if let Some(Some(frame)) = output.get_mut(0) {
|
||||
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();
|
||||
frame.push(buf);
|
||||
}
|
||||
}
|
||||
|
||||
fn play_from_sequence (
|
||||
output: &mut MIDIChunk,
|
||||
sequence: &PhraseData,
|
||||
timebase: &Arc<Timebase>,
|
||||
steps: usize,
|
||||
resolution: usize,
|
||||
frame: usize,
|
||||
frames: usize,
|
||||
) {
|
||||
let quant = timebase.frames_per_beat() as usize * steps / resolution;
|
||||
let ticks = 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn monitor_and_record (
|
||||
scope: &ProcessScope,
|
||||
output: &mut MIDIChunk,
|
||||
sequence: &mut PhraseData,
|
||||
midi_in: &Port<MidiIn>,
|
||||
notes_on: &mut Vec<bool>,
|
||||
playing: TransportState,
|
||||
monitoring: bool,
|
||||
recording: bool,
|
||||
tick: u32,
|
||||
) {
|
||||
for event in midi_in.iter(scope) {
|
||||
let msg = midly::live::LiveEvent::parse(event.bytes).unwrap();
|
||||
match msg {
|
||||
midly::live::LiveEvent::Midi { channel: _, message } => match message {
|
||||
midly::MidiMessage::NoteOn { key, vel: _ } => {
|
||||
notes_on[key.as_int() as usize] = true;
|
||||
if 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 recording && 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: _ } => {
|
||||
notes_on[key.as_int() as usize] = false;
|
||||
if 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 recording && 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()]);
|
||||
}
|
||||
}
|
||||
},
|
||||
_ => {}
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue