wip: refactor pt.5, no translate

crates/tek_api/src/sampler.rs

@@ -62,13 +62,66 @@ impl Sampler {
             output_gain: 0.
         })
     }
-}
-
-/// A currently playing instance of a sample.
-#[derive(Default, Debug, Clone)]
-pub struct Voice {
-    pub sample:   Arc<RwLock<Sample>>,
-    pub after:    usize,
-    pub position: usize,
-    pub velocity: f32,
+    /// Immutable reference to sample at cursor.
+    pub fn sample (&self) -> Option<&Arc<RwLock<Sample>>> {
+        for (i, sample) in self.mapped.values().enumerate() {
+            if i == self.cursor.0 {
+                return Some(sample)
+            }
+        }
+        for (i, sample) in self.unmapped.iter().enumerate() {
+            if i + self.mapped.len() == self.cursor.0 {
+                return Some(sample)
+            }
+        }
+        None
+    }
+    /// Create [Voice]s from [Sample]s in response to MIDI input.
+    pub fn process_midi_in (&mut self, scope: &ProcessScope) {
+        for RawMidi { time, bytes } in self.ports.midi_ins.get("midi").unwrap().iter(scope) {
+            if let LiveEvent::Midi { message, .. } = LiveEvent::parse(bytes).unwrap() {
+                if let MidiMessage::NoteOn { ref key, ref vel } = message {
+                    if let Some(sample) = self.mapped.get(key) {
+                        self.voices.write().unwrap().push(Sample::play(sample, time as usize, vel));
+                    }
+                }
+            }
+        }
+    }
+    /// Zero the output buffer.
+    pub fn clear_output_buffer (&mut self) {
+        for buffer in self.buffer.iter_mut() {
+            buffer.fill(0.0);
+        }
+    }
+    /// Mix all currently playing samples into the output.
+    pub fn process_audio_out (&mut self, scope: &ProcessScope) {
+        let channel_count = self.buffer.len();
+        self.voices.write().unwrap().retain_mut(|voice|{
+            for index in 0..scope.n_frames() as usize {
+                if let Some(frame) = voice.next() {
+                    for (channel, sample) in frame.iter().enumerate() {
+                        // Averaging mixer:
+                        //self.buffer[channel % channel_count][index] = (
+                            //(self.buffer[channel % channel_count][index] + sample * self.output_gain) / 2.0
+                        //);
+                        self.buffer[channel % channel_count][index] +=
+                            sample * self.output_gain;
+                    }
+                } else {
+                    return false
+                }
+            }
+            return true
+        });
+    }
+    /// Write output buffer to output ports.
+    pub fn write_output_buffer (&mut self, scope: &ProcessScope) {
+        for (i, port) in self.ports.audio_outs.values_mut().enumerate() {
+            let buffer = &self.buffer[i];
+            for (i, value) in port.as_mut_slice(scope).iter_mut().enumerate() {
+                *value = *buffer.get(i).unwrap_or(&0.0);
+            }
+        }
+    }
 }