mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 11:46:41 +01:00
452 lines
16 KiB
Rust
452 lines
16 KiB
Rust
//! MIDI player
|
|
use crate::*;
|
|
|
|
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 }
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait MidiPlayerApi: MidiRecordApi + MidiPlaybackApi + Send + Sync {}
|
|
|
|
impl MidiPlayerApi for MidiPlayer {}
|
|
|
|
/// Contains state for playing a clip
|
|
pub struct MidiPlayer {
|
|
/// State of clock and playhead
|
|
pub clock: Clock,
|
|
/// Start time and clip being played
|
|
pub play_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
|
|
/// Start time and next clip
|
|
pub next_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
|
|
/// 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_ins: Vec<JackMidiIn>,
|
|
/// Play from current sequence to MIDI ports
|
|
pub midi_outs: Vec<JackMidiOut>,
|
|
/// Notes currently held at input
|
|
pub notes_in: Arc<RwLock<[bool; 128]>>,
|
|
/// Notes currently held at output
|
|
pub notes_out: Arc<RwLock<[bool; 128]>>,
|
|
/// MIDI output buffer
|
|
pub note_buf: Vec<u8>,
|
|
}
|
|
|
|
impl Default for MidiPlayer {
|
|
fn default () -> Self {
|
|
Self {
|
|
play_clip: None,
|
|
next_clip: None,
|
|
recording: false,
|
|
monitoring: false,
|
|
overdub: false,
|
|
|
|
notes_in: RwLock::new([false;128]).into(),
|
|
notes_out: RwLock::new([false;128]).into(),
|
|
note_buf: vec![0;8],
|
|
reset: true,
|
|
|
|
midi_ins: vec![],
|
|
midi_outs: vec![],
|
|
clock: Clock::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl MidiPlayer {
|
|
pub fn new (
|
|
name: impl AsRef<str>,
|
|
jack: &Jack,
|
|
clock: Option<&Clock>,
|
|
clip: Option<&Arc<RwLock<MidiClip>>>,
|
|
midi_from: &[PortConnect],
|
|
midi_to: &[PortConnect],
|
|
) -> Usually<Self> {
|
|
let _name = name.as_ref();
|
|
let clock = clock.cloned().unwrap_or_default();
|
|
Ok(Self {
|
|
midi_ins: vec![JackMidiIn::new(jack, format!("M/{}", name.as_ref()), midi_from)?,],
|
|
midi_outs: vec![JackMidiOut::new(jack, format!("{}/M", name.as_ref()), midi_to)?, ],
|
|
play_clip: clip.map(|clip|(Moment::zero(&clock.timebase), Some(clip.clone()))),
|
|
clock,
|
|
note_buf: vec![0;8],
|
|
reset: true,
|
|
recording: false,
|
|
monitoring: false,
|
|
overdub: false,
|
|
next_clip: None,
|
|
notes_in: RwLock::new([false;128]).into(),
|
|
notes_out: RwLock::new([false;128]).into(),
|
|
})
|
|
}
|
|
}
|
|
|
|
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_clip", &self.play_clip)
|
|
.field("next_clip", &self.next_clip)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
has_clock!(|self: MidiPlayer|self.clock);
|
|
|
|
impl HasMidiIns for MidiPlayer {
|
|
fn midi_ins (&self) -> &Vec<JackMidiIn> { &self.midi_ins }
|
|
fn midi_ins_mut (&mut self) -> &mut Vec<JackMidiIn> { &mut self.midi_ins }
|
|
}
|
|
|
|
impl HasMidiOuts for MidiPlayer {
|
|
fn midi_outs (&self) -> &Vec<JackMidiOut> { &self.midi_outs }
|
|
fn midi_outs_mut (&mut self) -> &mut Vec<JackMidiOut> { &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 clip 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 clip 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 HasPlayClip for MidiPlayer {
|
|
fn reset (&self) -> bool {
|
|
self.reset
|
|
}
|
|
fn reset_mut (&mut self) -> &mut bool {
|
|
&mut self.reset
|
|
}
|
|
fn play_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
|
|
&self.play_clip
|
|
}
|
|
fn play_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
|
|
&mut self.play_clip
|
|
}
|
|
fn next_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
|
|
&self.next_clip
|
|
}
|
|
fn next_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
|
|
&mut self.next_clip
|
|
}
|
|
}
|
|
|
|
pub trait MidiRecordApi: HasClock + HasPlayClip + 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 overdub (&self) -> bool;
|
|
|
|
fn overdub_mut (&mut self) -> &mut bool;
|
|
|
|
fn toggle_overdub (&mut self) {
|
|
*self.overdub_mut() = !self.overdub();
|
|
}
|
|
|
|
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.port().iter(scope)) {
|
|
if let LiveEvent::Midi { message, .. } = event {
|
|
if monitoring {
|
|
midi_buf[sample].push(bytes.to_vec());
|
|
}
|
|
// FIXME: don't lock on every event!
|
|
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_clip().clone() {
|
|
self.record_clip(scope, started, clip, midi_buf);
|
|
}
|
|
if let Some((_start_at, _clip)) = &self.next_clip() {
|
|
self.record_next();
|
|
}
|
|
}
|
|
|
|
fn record_clip (
|
|
&mut self,
|
|
scope: &ProcessScope,
|
|
started: Moment,
|
|
clip: &Option<Arc<RwLock<MidiClip>>>,
|
|
_midi_buf: &mut Vec<Vec<Vec<u8>>>
|
|
) {
|
|
if let Some(clip) = clip {
|
|
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 clip = clip.write().unwrap();
|
|
let length = clip.length;
|
|
for input in self.midi_ins_mut().iter() {
|
|
for (sample, event, _bytes) in parse_midi_input(input.port().iter(scope)) {
|
|
if let LiveEvent::Midi { message, .. } = event {
|
|
clip.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
|
|
}
|
|
|
|
}
|
|
|
|
pub trait MidiPlaybackApi: HasPlayClip + 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
|
|
) {
|
|
let n_frames = (scope.n_frames() as usize).min(out.len());
|
|
for frame in &mut out[0..n_frames] {
|
|
frame.clear();
|
|
}
|
|
if reset {
|
|
all_notes_off(out);
|
|
}
|
|
}
|
|
|
|
/// Output notes from clip 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 clip is playing, write a chunk of MIDI events from it to the output buffer.
|
|
// If no clip is playing, prepare for switchover immediately.
|
|
self.play_clip().as_ref().map_or(true, |(started, clip)|{
|
|
self.play_chunk(scope, note_buf, out, started, clip)
|
|
})
|
|
}
|
|
|
|
/// Handle switchover from current to next playing clip.
|
|
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, clip)) = &self.next_clip() {
|
|
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 clip:
|
|
if start <= sample0.saturating_sub(sample) {
|
|
// Samples elapsed since clip was supposed to start
|
|
let _skipped = sample0 - start;
|
|
// Switch over to enqueued clip
|
|
let started = Moment::from_sample(self.clock().timebase(), start as f64);
|
|
// Launch enqueued clip
|
|
*self.play_clip_mut() = Some((started, clip.clone()));
|
|
// Unset enqueuement (TODO: where to implement looping?)
|
|
*self.next_clip_mut() = None;
|
|
// Fill in remaining ticks of chunk from next clip.
|
|
self.play(scope, note_buf, out);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn play_chunk (
|
|
&self,
|
|
scope: &ProcessScope,
|
|
note_buf: &mut Vec<u8>,
|
|
out: &mut [Vec<Vec<u8>>],
|
|
started: &Moment,
|
|
clip: &Option<Arc<RwLock<MidiClip>>>
|
|
) -> bool {
|
|
// First sample to populate. Greater than 0 means that the first
|
|
// pulse of the clip 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 clip 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 = clip.as_ref().map_or(0, |p|p.read().unwrap().length);
|
|
for (sample, pulse) in pulses {
|
|
// If a next clip is enqueued, and we're past the end of the current one,
|
|
// break the loop here (FIXME count pulse correctly)
|
|
let past_end = if clip.is_some() { pulse >= length } else { true };
|
|
if self.next_clip().is_some() && past_end {
|
|
return true
|
|
}
|
|
// If there's a currently playing clip, output notes from it to buffer:
|
|
if let Some(ref clip) = clip {
|
|
Self::play_pulse(clip, pulse, sample, note_buf, out, notes)
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
fn play_pulse (
|
|
clip: &RwLock<MidiClip>,
|
|
pulse: usize,
|
|
sample: usize,
|
|
note_buf: &mut Vec<u8>,
|
|
out: &mut [Vec<Vec<u8>>],
|
|
notes: &mut [bool;128]
|
|
) {
|
|
// Source clip from which the MIDI events will be taken.
|
|
let clip = clip.read().unwrap();
|
|
// Clip with zero length is not processed
|
|
if clip.length > 0 {
|
|
// Current pulse index in source clip
|
|
let pulse = pulse % clip.length;
|
|
// Output each MIDI event from clip at appropriate frames of output buffer:
|
|
for message in clip.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.port_mut().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:?}");
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|