mirror of
https://codeberg.org/unspeaker/tek.git
synced 2026-07-17 07:46:57 +02:00
646 lines
24 KiB
Rust
646 lines
24 KiB
Rust
use crate::{*, clock::*, device::*};
|
|
|
|
impl <T: AsRef<Sequencer>+AsMut<Sequencer>> HasSequencer for T {}
|
|
|
|
/// A MIDI sequence.
|
|
///
|
|
/// ```
|
|
/// let clip = tek::MidiClip::default();
|
|
/// ```
|
|
#[derive(Debug, Clone, Default)] pub struct MidiClip {
|
|
pub uuid: uuid::Uuid,
|
|
/// Name of clip
|
|
pub name: Arc<str>,
|
|
/// Temporal resolution in pulses per quarter note
|
|
pub ppq: usize,
|
|
/// Length of clip in pulses
|
|
pub length: usize,
|
|
/// Notes in clip
|
|
pub notes: MidiData,
|
|
/// Whether to loop the clip or play it once
|
|
pub looped: bool,
|
|
/// Start of loop
|
|
pub loop_start: usize,
|
|
/// Length of loop
|
|
pub loop_length: usize,
|
|
/// All notes are displayed with minimum length
|
|
pub percussive: bool,
|
|
/// Identifying color of clip
|
|
pub color: ItemTheme,
|
|
}
|
|
|
|
/// Contains state for playing a clip
|
|
///
|
|
/// ```
|
|
/// let clip = tek::MidiClip::default();
|
|
/// println!("Empty clip: {clip:?}");
|
|
///
|
|
/// let clip = tek::MidiClip::stop_all();
|
|
/// println!("Panic clip: {clip:?}");
|
|
///
|
|
/// let mut clip = tek::MidiClip::new("clip", true, 1, None, None);
|
|
/// clip.set_length(96);
|
|
/// clip.toggle_loop();
|
|
/// clip.record_event(12, midly::MidiMessage::NoteOn { key: 36.into(), vel: 100.into() });
|
|
/// assert!(clip.contains_note_on(36.into(), 6, 18));
|
|
/// assert_eq!(&clip.notes, &clip.duplicate().notes);
|
|
///
|
|
/// let clip = std::sync::Arc::new(clip);
|
|
/// assert_eq!(clip.clone(), clip);
|
|
///
|
|
/// let sequencer = tek::Sequencer::default();
|
|
/// println!("{sequencer:?}");
|
|
/// ```
|
|
pub struct Sequencer {
|
|
/// State of clock and playhead
|
|
#[cfg(feature = "clock")] pub clock: Clock,
|
|
/// Start time and clip being played
|
|
#[cfg(feature = "clip")] pub play_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
|
|
/// Start time and next clip
|
|
#[cfg(feature = "clip")] pub next_clip: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
|
|
/// Record from MIDI ports to current sequence.
|
|
#[cfg(feature = "port")] pub midi_ins: Vec<MidiInput>,
|
|
/// Play from current sequence to MIDI ports
|
|
#[cfg(feature = "port")] pub midi_outs: Vec<MidiOutput>,
|
|
/// 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)
|
|
/// 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>,
|
|
/// MIDI output buffer
|
|
pub midi_buf: Vec<Vec<Vec<u8>>>,
|
|
}
|
|
|
|
|
|
pub trait HasPlayClip: HasClock {
|
|
fn reset (&self) -> bool;
|
|
fn reset_mut (&mut self) -> &mut bool;
|
|
fn play_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
|
fn play_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
|
fn next_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
|
fn next_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
|
|
|
fn pulses_since_start (&self) -> Option<f64> {
|
|
if let Some((started, Some(_))) = self.play_clip().as_ref() {
|
|
let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
|
|
return Some(elapsed)
|
|
}
|
|
None
|
|
}
|
|
|
|
fn pulses_since_start_looped (&self) -> Option<(f64, f64)> {
|
|
if let Some((started, Some(clip))) = self.play_clip().as_ref() {
|
|
let elapsed = self.clock().playhead.pulse.get() - started.pulse.get();
|
|
let length = clip.read().unwrap().length.max(1); // prevent div0 on empty clip
|
|
let times = (elapsed as usize / length) as f64;
|
|
let elapsed = (elapsed as usize % length) as f64;
|
|
return Some((times, elapsed))
|
|
}
|
|
None
|
|
}
|
|
|
|
fn enqueue_next (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
|
|
*self.next_clip_mut() = Some((self.clock().next_launch_instant(), clip.cloned()));
|
|
*self.reset_mut() = true;
|
|
}
|
|
|
|
fn play_status (&self) -> impl Draw<Tui> {
|
|
let (name, color): (Arc<str>, ItemTheme) = if let Some((_, Some(clip))) = self.play_clip() {
|
|
let MidiClip { ref name, color, .. } = *clip.read().unwrap();
|
|
(name.clone(), color)
|
|
} else {
|
|
("".into(), ItemTheme::G[64].into())
|
|
};
|
|
field_v(color, "Now:", format!("{} {}", self.play_status_time(), name))
|
|
}
|
|
|
|
fn play_status_time (&self) -> String {
|
|
self.pulses_since_start_looped()
|
|
.map(|(times, time)|format!("{:>3}x {:>}", times+1.0, self.clock().timebase.format_beats_1(time)))
|
|
.unwrap_or_else(||String::from(" "))
|
|
.into()
|
|
}
|
|
|
|
fn next_status (&self) -> impl Draw<Tui> {
|
|
let mut time: Arc<str> = String::from("--.-.--").into();
|
|
let mut name: Arc<str> = String::from("").into();
|
|
let mut color = ItemTheme::G[64];
|
|
let clock = self.clock();
|
|
if let Some((t, Some(clip))) = self.next_clip() {
|
|
let clip = clip.read().unwrap();
|
|
name = clip.name.clone();
|
|
color = clip.color.clone();
|
|
time = {
|
|
let target = t.pulse.get();
|
|
let current = clock.playhead.pulse.get();
|
|
if target > current {
|
|
let remaining = target - current;
|
|
format!("-{:>}", clock.timebase.format_beats_1(remaining))
|
|
} else {
|
|
String::new()
|
|
}
|
|
}.into()
|
|
} else if let Some((t, Some(clip))) = self.play_clip() {
|
|
let clip = clip.read().unwrap();
|
|
if clip.looped {
|
|
name = clip.name.clone();
|
|
color = clip.color.clone();
|
|
let target = t.pulse.get() + clip.length as f64;
|
|
let current = clock.playhead.pulse.get();
|
|
if target > current {
|
|
time = format!("-{:>}", clock.timebase.format_beats_0(target - current)).into()
|
|
}
|
|
} else {
|
|
name = "Stop".to_string().into();
|
|
}
|
|
};
|
|
field_v(color, "Next:", format!("{} {}", time, name))
|
|
}
|
|
}
|
|
|
|
pub trait MidiMonitor: HasMidiIns + HasMidiBuffers {
|
|
/// Input note flags.
|
|
fn notes_in (&self) -> &Arc<RwLock<[bool;128]>>;
|
|
/// Current monitoring status.
|
|
fn monitoring (&self) -> bool;
|
|
/// Mutable monitoring status.
|
|
fn monitoring_mut (&mut self) -> &mut bool;
|
|
/// Enable or disable monitoring.
|
|
fn toggle_monitor (&mut self) { *self.monitoring_mut() = !self.monitoring(); }
|
|
/// Perform monitoring.
|
|
fn monitor (&mut self, _scope: &ProcessScope) { /* do nothing by default */ }
|
|
}
|
|
|
|
pub trait MidiRecord: MidiMonitor + HasClock + HasPlayClip {
|
|
fn recording (&self) -> bool;
|
|
fn recording_mut (&mut self) -> &mut bool;
|
|
fn toggle_record (&mut self) {
|
|
*self.recording_mut() = !self.recording();
|
|
}
|
|
|
|
fn overdub (&self) -> bool;
|
|
fn overdub_mut (&mut self) -> &mut bool;
|
|
fn toggle_overdub (&mut self) {
|
|
*self.overdub_mut() = !self.overdub();
|
|
}
|
|
|
|
fn record_clip (
|
|
&mut self,
|
|
scope: &ProcessScope,
|
|
started: Moment,
|
|
clip: &Option<Arc<RwLock<MidiClip>>>,
|
|
) {
|
|
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 type MidiData = Vec<Vec<MidiMessage>>;
|
|
pub type ClipPool = Vec<Arc<RwLock<MidiClip>>>;
|
|
pub type CollectedMidiInput<'a> = Vec<Vec<(u32, Result<LiveEvent<'a>, MidiError>)>>;
|
|
|
|
pub trait HasClips {
|
|
fn clips <'a> (&'a self) -> std::sync::RwLockReadGuard<'a, ClipPool>;
|
|
fn clips_mut <'a> (&'a self) -> std::sync::RwLockWriteGuard<'a, ClipPool>;
|
|
fn add_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {
|
|
let clip = Arc::new(RwLock::new(MidiClip::new("Clip", true, 384, None, None)));
|
|
self.clips_mut().push(clip.clone());
|
|
(self.clips().len() - 1, clip)
|
|
}
|
|
}
|
|
|
|
pub trait HasMidiClip {
|
|
fn clip (&self) -> Option<Arc<RwLock<MidiClip>>>;
|
|
}
|
|
|
|
pub trait HasSequencer: AsRef<Sequencer> + AsMut<Sequencer> {
|
|
fn sequencer_mut (&mut self) -> &mut Sequencer { self.as_mut() }
|
|
fn sequencer (&self) -> &Sequencer { self.as_ref() }
|
|
}
|
|
|
|
pub trait HasMidiBuffers {
|
|
fn note_buf_mut (&mut self) -> &mut Vec<u8>;
|
|
fn midi_buf_mut (&mut self) -> &mut Vec<Vec<Vec<u8>>>;
|
|
}
|
|
|
|
impl MidiClip {
|
|
pub fn new (
|
|
name: impl AsRef<str>,
|
|
looped: bool,
|
|
length: usize,
|
|
notes: Option<MidiData>,
|
|
color: Option<ItemTheme>,
|
|
) -> Self {
|
|
Self {
|
|
uuid: uuid::Uuid::new_v4(),
|
|
name: name.as_ref().into(),
|
|
ppq: PPQ,
|
|
length,
|
|
notes: notes.unwrap_or(vec![Vec::with_capacity(16);length]),
|
|
looped,
|
|
loop_start: 0,
|
|
loop_length: length,
|
|
percussive: true,
|
|
color: color.unwrap_or_else(ItemTheme::random)
|
|
}
|
|
}
|
|
pub fn count_midi_messages (&self) -> usize {
|
|
let mut count = 0;
|
|
for tick in self.notes.iter() {
|
|
count += tick.len();
|
|
}
|
|
count
|
|
}
|
|
pub fn set_length (&mut self, length: usize) {
|
|
self.length = length;
|
|
self.notes = vec![Vec::with_capacity(16);length];
|
|
}
|
|
pub fn duplicate (&self) -> Self {
|
|
let mut clone = self.clone();
|
|
clone.uuid = uuid::Uuid::new_v4();
|
|
clone
|
|
}
|
|
pub fn toggle_loop (&mut self) { self.looped = !self.looped; }
|
|
pub fn record_event (&mut self, pulse: usize, message: MidiMessage) {
|
|
if pulse >= self.length { panic!("extend clip first") }
|
|
self.notes[pulse].push(message);
|
|
}
|
|
/// Check if a range `start..end` contains MIDI Note On `k`
|
|
pub fn contains_note_on (&self, k: u7, start: usize, end: usize) -> bool {
|
|
for events in self.notes[start.max(0)..end.min(self.notes.len())].iter() {
|
|
for event in events.iter() {
|
|
if let MidiMessage::NoteOn {key,..} = event { if *key == k { return true } }
|
|
}
|
|
}
|
|
false
|
|
}
|
|
pub fn stop_all () -> Self {
|
|
Self::new(
|
|
"Stop",
|
|
false,
|
|
1,
|
|
Some(vec![vec![MidiMessage::Controller {
|
|
controller: 123.into(),
|
|
value: 0.into()
|
|
}]]),
|
|
Some(ItemColor::from_tui(Color::Rgb(32, 32, 32)).into())
|
|
)
|
|
}
|
|
}
|
|
|
|
impl PartialEq for MidiClip {
|
|
fn eq (&self, other: &Self) -> bool {
|
|
self.uuid == other.uuid
|
|
}
|
|
}
|
|
|
|
impl Eq for MidiClip {}
|
|
|
|
impl MidiClip {
|
|
fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
|
|
fn _todo_bool_stub_ (&self) -> bool { todo!() }
|
|
fn _todo_usize_stub_ (&self) -> usize { todo!() }
|
|
fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
|
|
fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
|
|
fn _todo_opt_item_theme_stub (&self) -> Option<ItemTheme> { todo!() }
|
|
}
|
|
impl_has!(Sequencer: |self: Track| self.sequencer);
|
|
impl_has!(Clock: |self: Sequencer| self.clock);
|
|
impl_has!(Vec<MidiInput>: |self: Sequencer| self.midi_ins);
|
|
impl_has!(Vec<MidiOutput>: |self: Sequencer| self.midi_outs);
|
|
impl_default!(Sequencer: Self {
|
|
clock: Clock::default(),
|
|
play_clip: None,
|
|
next_clip: None,
|
|
midi_ins: vec![],
|
|
midi_outs: vec![],
|
|
recording: false,
|
|
monitoring: true,
|
|
overdub: false,
|
|
notes_in: RwLock::new([false;128]).into(),
|
|
notes_out: RwLock::new([false;128]).into(),
|
|
note_buf: vec![0;8],
|
|
midi_buf: vec![],
|
|
reset: true,
|
|
});
|
|
impl Sequencer {
|
|
pub fn new (
|
|
name: impl AsRef<str>,
|
|
jack: &Jack<'static>,
|
|
#[cfg(feature = "clock")] clock: Option<&Clock>,
|
|
#[cfg(feature = "clip")] clip: Option<&Arc<RwLock<MidiClip>>>,
|
|
#[cfg(feature = "port")] midi_from: &[Connect],
|
|
#[cfg(feature = "port")] midi_to: &[Connect],
|
|
) -> Usually<Self> {
|
|
let _name = name.as_ref();
|
|
#[cfg(feature = "clock")] let clock = clock.cloned().unwrap_or_default();
|
|
Ok(Self {
|
|
reset: true,
|
|
notes_in: RwLock::new([false;128]).into(),
|
|
notes_out: RwLock::new([false;128]).into(),
|
|
#[cfg(feature = "port")] midi_ins: vec![MidiInput::new(jack, &format!("M/{}", name.as_ref()), midi_from)?,],
|
|
#[cfg(feature = "port")] midi_outs: vec![MidiOutput::new(jack, &format!("{}/M", name.as_ref()), midi_to)?, ],
|
|
#[cfg(feature = "clip")] play_clip: clip.map(|clip|(Moment::zero(&clock.timebase), Some(clip.clone()))),
|
|
#[cfg(feature = "clock")] clock,
|
|
..Default::default()
|
|
})
|
|
}
|
|
fn process_rolling (&mut self, scope: &ProcessScope) -> Control {
|
|
self.process_clear(scope, false);
|
|
// Write chunk of clip to output, handle switchover
|
|
if self.process_playback(scope) {
|
|
self.process_switchover(scope);
|
|
}
|
|
// Monitor input to output
|
|
self.process_monitoring(scope);
|
|
// Record and/or monitor input
|
|
self.process_recording(scope);
|
|
// Emit contents of MIDI buffers to JACK MIDI output ports.
|
|
self.midi_outs_emit(scope);
|
|
Control::Continue
|
|
}
|
|
fn process_stopped (&mut self, scope: &ProcessScope) -> Control {
|
|
if self.monitoring() && self.midi_ins().len() > 0 && self.midi_outs().len() > 0 {
|
|
self.process_monitoring(scope)
|
|
}
|
|
Control::Continue
|
|
}
|
|
fn process_monitoring (&mut self, scope: &ProcessScope) {
|
|
let notes_in = self.notes_in().clone(); // For highlighting keys and note repeat
|
|
let monitoring = self.monitoring();
|
|
for input in self.midi_ins.iter() {
|
|
for (sample, event, bytes) in input.parsed(scope) {
|
|
if let LiveEvent::Midi { message, .. } = event {
|
|
if monitoring {
|
|
self.midi_buf[sample].push(bytes.to_vec());
|
|
}
|
|
// FIXME: don't lock on every event!
|
|
update_keys(&mut notes_in.write().unwrap(), &message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// Clear the section of the output buffer that we will be using,
|
|
/// emitting "all notes off" at start of buffer if requested.
|
|
fn process_clear (&mut self, scope: &ProcessScope, reset: bool) {
|
|
let n_frames = (scope.n_frames() as usize).min(self.midi_buf_mut().len());
|
|
for frame in &mut self.midi_buf_mut()[0..n_frames] {
|
|
frame.clear();
|
|
}
|
|
if reset {
|
|
all_notes_off(self.midi_buf_mut());
|
|
}
|
|
for port in self.midi_outs_mut().iter_mut() {
|
|
// Clear output buffer(s)
|
|
port.buffer_clear(scope, false);
|
|
}
|
|
}
|
|
fn process_recording (&mut self, scope: &ProcessScope) {
|
|
if self.monitoring() {
|
|
self.monitor(scope);
|
|
}
|
|
if let Some((started, ref clip)) = self.play_clip.clone() {
|
|
self.record_clip(scope, started, clip);
|
|
}
|
|
if let Some((_start_at, _clip)) = &self.next_clip() {
|
|
self.record_next();
|
|
}
|
|
}
|
|
fn process_playback (&mut self, scope: &ProcessScope) -> bool {
|
|
// 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.
|
|
if let Some((started, clip)) = &self.play_clip {
|
|
// Length of clip, to repeat or stop on end.
|
|
let length = clip.as_ref().map_or(0, |p|p.read().unwrap().length);
|
|
// Index of first sample to populate.
|
|
let offset = self.clock().get_sample_offset(scope, &started);
|
|
// Write MIDI events from clip at sample offsets corresponding to pulses.
|
|
for (sample, pulse) in self.clock().get_pulses(scope, offset) {
|
|
// 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 };
|
|
// Is it time for switchover?
|
|
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(clip) = clip {
|
|
// 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() {
|
|
for port in self.midi_outs.iter_mut() {
|
|
port.buffer_write(sample, LiveEvent::Midi {
|
|
channel: 0.into(), /* TODO */
|
|
message: *message
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
false
|
|
} else {
|
|
true
|
|
}
|
|
}
|
|
/// Handle switchover from current to next playing clip.
|
|
fn process_switchover (&mut self, scope: &ProcessScope) {
|
|
let _midi_buf = self.midi_buf_mut();
|
|
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.process_playback(scope);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl HasMidiBuffers for Sequencer {
|
|
fn note_buf_mut (&mut self) -> &mut Vec<u8> { &mut self.note_buf }
|
|
fn midi_buf_mut (&mut self) -> &mut Vec<Vec<Vec<u8>>> { &mut self.midi_buf }
|
|
}
|
|
impl std::fmt::Debug for Sequencer {
|
|
fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
|
|
f.debug_struct("Sequencer")
|
|
.field("clock", &self.clock)
|
|
.field("play_clip", &self.play_clip)
|
|
.field("next_clip", &self.next_clip)
|
|
.finish()
|
|
}
|
|
}
|
|
impl MidiMonitor for Sequencer {
|
|
fn monitoring (&self) -> bool { self.monitoring }
|
|
fn monitoring_mut (&mut self) -> &mut bool { &mut self.monitoring }
|
|
fn notes_in (&self) -> &Arc<RwLock<[bool; 128]>> { &self.notes_in }
|
|
}
|
|
impl MidiRecord for Sequencer {
|
|
fn recording (&self) -> bool { self.recording }
|
|
fn recording_mut (&mut self) -> &mut bool { &mut self.recording }
|
|
fn overdub (&self) -> bool { self.overdub }
|
|
fn overdub_mut (&mut self) -> &mut bool { &mut self.overdub }
|
|
}
|
|
#[cfg(feature="clip")] impl HasPlayClip for Sequencer {
|
|
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
|
|
}
|
|
}
|
|
/// JACK process callback for a sequencer's clip sequencer/recorder.
|
|
impl Audio for Sequencer {
|
|
fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
|
|
if self.clock().is_rolling() {
|
|
self.process_rolling(scope)
|
|
} else {
|
|
self.process_stopped(scope)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Iterator for Ticker {
|
|
type Item = (usize, usize);
|
|
fn next (&mut self) -> Option<Self::Item> {
|
|
loop {
|
|
if self.sample > self.end { return None }
|
|
let spp = self.spp;
|
|
let sample = self.sample as f64;
|
|
let start = self.start;
|
|
let end = self.end;
|
|
self.sample += 1;
|
|
//println!("{spp} {sample} {start} {end}");
|
|
let jitter = sample.rem_euclid(spp); // ramps
|
|
let next_jitter = (sample + 1.0).rem_euclid(spp);
|
|
if jitter > next_jitter { // at crossing:
|
|
let time = (sample as usize) % (end as usize-start as usize);
|
|
let tick = (sample / spp) as usize;
|
|
return Some((time, tick))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn to_key (note: usize) -> &'static str {
|
|
match note % 12 {
|
|
11 | 9 | 7 | 5 | 4 | 2 | 0 => "████▌",
|
|
10 | 8 | 6 | 3 | 1 => " ",
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn note_y_iter (note_lo: usize, note_hi: usize, y0: u16)
|
|
-> impl Iterator<Item=(usize, u16, usize)>
|
|
{
|
|
(note_lo..=note_hi).rev().enumerate().map(move|(y, n)|(y, y0 + y as u16, n))
|
|
}
|
|
|
|
/// Return boxed iterator of MIDI events
|
|
pub fn parse_midi_input <'a> (input: ::tengri::jack::MidiIter<'a>)
|
|
-> Box<dyn Iterator<Item=(usize, LiveEvent<'a>, &'a [u8])> + 'a>
|
|
{
|
|
Box::new(input.map(|::tengri::jack::RawMidi { time, bytes }|(
|
|
time as usize,
|
|
LiveEvent::parse(bytes).unwrap(),
|
|
bytes
|
|
)))
|
|
}
|
|
|
|
/// Add "all notes off" to the start of a buffer.
|
|
pub fn all_notes_off (output: &mut [Vec<Vec<u8>>]) {
|
|
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();
|
|
output[0].push(buf);
|
|
}
|
|
|
|
/// Update notes_in array
|
|
pub fn update_keys (keys: &mut[bool;128], message: &MidiMessage) {
|
|
match message {
|
|
MidiMessage::NoteOn { key, .. } => { keys[key.as_int() as usize] = true; }
|
|
MidiMessage::NoteOff { key, .. } => { keys[key.as_int() as usize] = false; },
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
/// Returns the next shorter length
|
|
pub fn note_duration_prev (pulses: usize) -> usize {
|
|
for (length, _) in NOTE_DURATIONS.iter().rev() { if *length < pulses { return *length } }
|
|
pulses
|
|
}
|
|
|
|
/// Returns the next longer length
|
|
pub fn note_duration_next (pulses: usize) -> usize {
|
|
for (length, _) in NOTE_DURATIONS.iter() { if *length > pulses { return *length } }
|
|
pulses
|
|
}
|
|
|
|
pub fn note_duration_to_name (pulses: usize) -> &'static str {
|
|
for (length, name) in NOTE_DURATIONS.iter() { if *length == pulses { return name } }
|
|
""
|
|
}
|
|
|
|
pub fn note_pitch_to_name (n: usize) -> &'static str {
|
|
if n > 127 {
|
|
panic!("to_note_name({n}): must be 0-127");
|
|
}
|
|
NOTE_NAMES[n]
|
|
}
|