wip: modularize once again

midi/src/midi_player.rs

@@ -0,0 +1,280 @@
+use crate::*;
+
+pub trait MidiPlayerApi: MidiRecordApi + MidiPlaybackApi + Send + Sync {}
+
+impl MidiPlayerApi for MidiPlayer {}
+
+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 }
+        }
+    }
+}
+
+/// Contains state for playing a phrase
+pub struct MidiPlayer {
+    /// State of clock and playhead
+    pub(crate) clock:       Clock,
+    /// Start time and phrase being played
+    pub(crate) play_phrase: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Start time and next phrase
+    pub(crate) next_phrase: Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>,
+    /// Play input through output.
+    pub(crate) monitoring:  bool,
+    /// Write input to sequence.
+    pub(crate) recording:   bool,
+    /// Overdub input to sequence.
+    pub(crate) overdub:     bool,
+    /// Send all notes off
+    pub(crate) reset:       bool, // TODO?: after Some(nframes)
+    /// Record from MIDI ports to current sequence.
+    pub midi_ins:           Vec<Port<MidiIn>>,
+    /// Play from current sequence to MIDI ports
+    pub midi_outs:          Vec<Port<MidiOut>>,
+    /// Notes currently held at input
+    pub(crate) notes_in:    Arc<RwLock<[bool; 128]>>,
+    /// Notes currently held at output
+    pub(crate) notes_out:   Arc<RwLock<[bool; 128]>>,
+    /// MIDI output buffer
+    pub note_buf:           Vec<u8>,
+}
+impl MidiPlayer {
+    pub fn new (
+        jack:      &Arc<RwLock<JackConnection>>,
+        name:      impl AsRef<str>,
+        midi_from: &[impl AsRef<str>],
+        midi_to:   &[impl AsRef<str>],
+    ) -> Usually<Self> {
+        let name     = name.as_ref();
+        let midi_in  = jack.midi_in(&format!("M/{name}"), midi_from)?;
+        let midi_out = jack.midi_out(&format!("{name}/M"), midi_to)?;
+        Ok(Self {
+            clock:       Clock::from(jack),
+            play_phrase: None,
+            next_phrase: None,
+            recording:   false,
+            monitoring:  false,
+            overdub:     false,
+
+            notes_in:    RwLock::new([false;128]).into(),
+            midi_ins:    vec![midi_in],
+            midi_outs:   vec![midi_out],
+            notes_out:   RwLock::new([false;128]).into(),
+            reset:       true,
+
+            note_buf:    vec![0;8],
+        })
+    }
+    pub fn play_status (&self) -> impl Content<TuiOut> {
+        ClipSelected::play_phrase(self)
+    }
+    pub fn next_status (&self) -> impl Content<TuiOut> {
+        ClipSelected::next_phrase(self)
+    }
+}
+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_phrase", &self.play_phrase)
+            .field("next_phrase", &self.next_phrase)
+            .finish()
+    }
+}
+from!(|clock: &Clock| MidiPlayer = Self {
+    clock:       clock.clone(),
+    midi_ins:    vec![],
+    midi_outs:   vec![],
+    note_buf:    vec![0;8],
+    reset:       true,
+    recording:   false,
+    monitoring:  false,
+    overdub:     false,
+    play_phrase: None,
+    next_phrase: None,
+    notes_in:    RwLock::new([false;128]).into(),
+    notes_out:   RwLock::new([false;128]).into(),
+});
+from!(|state: (&Clock, &Arc<RwLock<MidiClip>>)|MidiPlayer = {
+    let (clock, phrase) = state;
+    let mut model = Self::from(clock);
+    model.play_phrase = Some((Moment::zero(&clock.timebase), Some(phrase.clone())));
+    model
+});
+has_clock!(|self: MidiPlayer|&self.clock);
+
+impl HasMidiIns for MidiPlayer {
+    fn midi_ins (&self) -> &Vec<Port<MidiIn>> {
+        &self.midi_ins
+    }
+    fn midi_ins_mut (&mut self) -> &mut Vec<Port<MidiIn>> {
+        &mut self.midi_ins
+    }
+}
+
+impl HasMidiOuts for MidiPlayer {
+    fn midi_outs (&self) -> &Vec<Port<MidiOut>> {
+        &self.midi_outs
+    }
+    fn midi_outs_mut (&mut self) -> &mut Vec<Port<MidiOut>> {
+        &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 phrase 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 phrase 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 HasPlayPhrase for MidiPlayer {
+    fn reset (&self) -> bool {
+        self.reset
+    }
+    fn reset_mut (&mut self) -> &mut bool {
+        &mut self.reset
+    }
+    fn play_phrase (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.play_phrase
+    }
+    fn play_phrase_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.play_phrase
+    }
+    fn next_phrase (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &self.next_phrase
+    }
+    fn next_phrase_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)> {
+        &mut self.next_phrase
+    }
+}
+
+//#[derive(Debug)]
+//pub struct MIDIPlayer {
+    ///// Global timebase
+    //pub clock:        Arc<Clock>,
+    ///// Start time and phrase being played
+    //pub play_phrase:  Option<(Moment, Option<Arc<RwLock<Phrase>>>)>,
+    ///// Start time and next phrase
+    //pub next_phrase:  Option<(Moment, Option<Arc<RwLock<Phrase>>>)>,
+    ///// 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_inputs:  Vec<Port<MidiIn>>,
+    ///// Play from current sequence to MIDI ports
+    //pub midi_outputs: Vec<Port<MidiOut>>,
+    ///// MIDI output buffer
+    //pub midi_note:    Vec<u8>,
+    ///// MIDI output buffer
+    //pub midi_chunk:   Vec<Vec<Vec<u8>>>,
+    ///// Notes currently held at input
+    //pub notes_in:     Arc<RwLock<[bool; 128]>>,
+    ///// Notes currently held at output
+    //pub notes_out:    Arc<RwLock<[bool; 128]>>,
+//}
+
+///// Methods used primarily by the process callback
+//impl MIDIPlayer {
+    //pub fn new (
+        //jack:  &Arc<RwLock<JackConnection>>,
+        //clock: &Arc<Clock>,
+        //name:  &str
+    //) -> Usually<Self> {
+        //let jack = jack.read().unwrap();
+        //Ok(Self {
+            //clock:        clock.clone(),
+            //phrase:       None,
+            //next_phrase:  None,
+            //notes_in:     Arc::new(RwLock::new([false;128])),
+            //notes_out:    Arc::new(RwLock::new([false;128])),
+            //monitoring:   false,
+            //recording:    false,
+            //overdub:      true,
+            //reset:        true,
+            //midi_note:    Vec::with_capacity(8),
+            //midi_chunk:   vec![Vec::with_capacity(16);16384],
+            //midi_outputs: vec![
+                //jack.client().register_port(format!("{name}_out0").as_str(), MidiOut::default())?
+            //],
+            //midi_inputs:  vec![
+                //jack.client().register_port(format!("{name}_in0").as_str(), MidiIn::default())?
+            //],
+        //})
+    //}
+//}