wip: refactor pt.5, no translate

crates/tek_tui/src/tui_sampler.rs

@@ -1,22 +1,16 @@
 use crate::*;
 
 /// The sampler plugin plays sounds.
-pub struct Sampler<E: Engine> {
-    _engine:         PhantomData<E>,
-    pub jack:        Arc<RwLock<JackClient>>,
-    pub name:        String,
-    pub cursor:      (usize, usize),
-    pub editing:     Option<Arc<RwLock<Sample>>>,
-    pub mapped:      BTreeMap<u7, Arc<RwLock<Sample>>>,
-    pub unmapped:    Vec<Arc<RwLock<Sample>>>,
-    pub voices:      Arc<RwLock<Vec<Voice>>>,
-    pub ports:       JackPorts,
-    pub buffer:      Vec<Vec<f32>>,
-    pub modal:       Arc<Mutex<Option<Box<dyn Exit + Send>>>>,
-    pub output_gain: f32
+pub struct SamplerView<E: Engine> {
+    _engine:     PhantomData<E>,
+    pub state:   Sampler,
+    pub cursor:  (usize, usize),
+    pub editing: Option<Arc<RwLock<Sample>>>,
+    pub buffer:  Vec<Vec<f32>>,
+    pub modal:   Arc<Mutex<Option<Box<dyn Exit + Send>>>>,
 }
 
-impl<E: Engine> Sampler<E> {
+impl<E: Engine> SamplerView<E> {
     pub fn new (
         jack: &Arc<RwLock<JackClient>>,
         name: &str,
@@ -43,68 +37,6 @@ impl<E: Engine> Sampler<E> {
                 modal:    Default::default()
             }))
     }
-    /// 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);
-            }
-        }
-    }
 }
 
 /// A sound sample.