wip: modularize once again

midi/src/midi_out.rs

@@ -0,0 +1,160 @@
+use crate::*;
+
+/// Trait for thing that may output MIDI.
+pub trait HasMidiOuts {
+    fn midi_outs (&self) -> &Vec<Port<MidiOut>>;
+    fn midi_outs_mut (&mut self) -> &mut Vec<Port<MidiOut>>;
+    fn has_midi_outs (&self) -> bool {
+        !self.midi_outs().is_empty()
+    }
+    /// Buffer for serializing a MIDI event. FIXME rename
+    fn midi_note (&mut self) -> &mut Vec<u8>;
+}
+
+pub trait MidiPlaybackApi: HasPlayPhrase + 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
+    ) {
+        for frame in &mut out[0..scope.n_frames() as usize] {
+            frame.clear();
+        }
+        if reset {
+            all_notes_off(out);
+        }
+    }
+
+    /// Output notes from phrase 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 phrase is playing, write a chunk of MIDI events from it to the output buffer.
+        // If no phrase is playing, prepare for switchover immediately.
+        self.play_phrase().as_ref().map_or(true, |(started, phrase)|{
+            self.play_chunk(scope, note_buf, out, started, phrase)
+        })
+    }
+
+    /// Handle switchover from current to next playing phrase.
+    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, phrase)) = &self.next_phrase() {
+            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 phrase:
+            if start <= sample0.saturating_sub(sample) {
+                // Samples elapsed since phrase was supposed to start
+                let _skipped = sample0 - start;
+                // Switch over to enqueued phrase
+                let started = Moment::from_sample(self.clock().timebase(), start as f64);
+                // Launch enqueued phrase
+                *self.play_phrase_mut() = Some((started, phrase.clone()));
+                // Unset enqueuement (TODO: where to implement looping?)
+                *self.next_phrase_mut() = None;
+                // Fill in remaining ticks of chunk from next phrase.
+                self.play(scope, note_buf, out);
+            }
+        }
+    }
+
+    fn play_chunk (
+        &self,
+        scope:    &ProcessScope,
+        note_buf: &mut Vec<u8>,
+        out:      &mut [Vec<Vec<u8>>],
+        started:  &Moment,
+        phrase:   &Option<Arc<RwLock<MidiClip>>>
+    ) -> bool {
+        // First sample to populate. Greater than 0 means that the first
+        // pulse of the phrase 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 phrase 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 = phrase.as_ref().map_or(0, |p|p.read().unwrap().length);
+        for (sample, pulse) in pulses {
+            // If a next phrase is enqueued, and we're past the end of the current one,
+            // break the loop here (FIXME count pulse correctly)
+            let past_end = if phrase.is_some() { pulse >= length } else { true };
+            if self.next_phrase().is_some() && past_end {
+                return true
+            }
+            // If there's a currently playing phrase, output notes from it to buffer:
+            if let Some(ref phrase) = phrase {
+                Self::play_pulse(phrase, pulse, sample, note_buf, out, notes)
+            }
+        }
+        false
+    }
+
+    fn play_pulse (
+        phrase:   &RwLock<MidiClip>,
+        pulse:    usize,
+        sample:   usize,
+        note_buf: &mut Vec<u8>,
+        out:      &mut [Vec<Vec<u8>>],
+        notes:    &mut [bool;128]
+    ) {
+        // Source phrase from which the MIDI events will be taken.
+        let phrase = phrase.read().unwrap();
+        // Phrase with zero length is not processed
+        if phrase.length > 0 {
+            // Current pulse index in source phrase
+            let pulse = pulse % phrase.length;
+            // Output each MIDI event from phrase at appropriate frames of output buffer:
+            for message in phrase.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.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:?}");
+                });
+            }
+        }
+    }
+}