wip: refresh mixer components

crates/tek_mixer/src/sampler.rs

@@ -17,38 +17,9 @@ pub struct Sampler<E: Engine> {
 }
 
 impl<E: Engine> Sampler<E> {
-    pub fn from_edn <'e> (args: &[Edn<'e>]) -> Usually<JackDevice<Tui>> {
-        let mut name = String::new();
-        let mut dir  = String::new();
-        let mut samples = BTreeMap::new();
-        edn!(edn in args {
-            Edn::Map(map) => {
-                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
-                    name = String::from(*n);
-                }
-                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":dir")) {
-                    dir = String::from(*n);
-                }
-            },
-            Edn::List(args) => match args.get(0) {
-                Some(Edn::Symbol("sample")) => {
-                    let (midi, sample) = Sample::from_edn(&dir, &args[1..])?;
-                    if let Some(midi) = midi {
-                        samples.insert(midi, sample);
-                    } else {
-                        panic!("sample without midi binding: {}", sample.read().unwrap().name);
-                    }
-                },
-                _ => panic!("unexpected in sampler {name}: {args:?}")
-            },
-            _ => panic!("unexpected in sampler {name}: {edn:?}")
-        });
-        Self::new(&name, Some(samples))
-    }
-
     pub fn new (
         name: &str, mapped: Option<BTreeMap<u7, Arc<RwLock<Sample>>>>
-    ) -> Usually<JackDevice<Tui>> {
+    ) -> Usually<JackDevice<E>> {
         Jack::new(name)?
             .midi_in("midi")
             .audio_in("recL")
@@ -57,6 +28,7 @@ impl<E: Engine> Sampler<E> {
             .audio_out("outR")
             .run(|ports|Box::new(Self {
                 _engine:  Default::default(),
+                jack:     (),
                 name:     name.into(),
                 cursor:   (0, 0),
                 editing:  None,
@@ -69,7 +41,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() {
@@ -84,9 +55,8 @@ impl<E: Engine> Sampler<E> {
         }
         None
     }
-
     /// Create [Voice]s from [Sample]s in response to MIDI input.
-    fn process_midi_in (&mut self, scope: &ProcessScope) {
+    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 {
@@ -97,16 +67,14 @@ impl<E: Engine> Sampler<E> {
             }
         }
     }
-
     /// Zero the output buffer.
-    fn clear_output_buffer (&mut self) {
+    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.
-    fn process_audio_out (&mut self, scope: &ProcessScope) {
+    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 {
@@ -126,9 +94,8 @@ impl<E: Engine> Sampler<E> {
             return true
         });
     }
-
     /// Write output buffer to output ports.
-    fn write_output_buffer (&mut self, scope: &ProcessScope) {
+    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() {
@@ -137,16 +104,6 @@ impl<E: Engine> Sampler<E> {
         }
     }
 }
-
-impl<E: Engine> Audio for Sampler<E> {
-    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
-        self.process_midi_in(scope);
-        self.clear_output_buffer();
-        self.process_audio_out(scope);
-        self.write_output_buffer(scope);
-        Control::Continue
-    }
-}
 impl Handle<Tui> for Sampler<Tui> {
     fn handle (&mut self, from: &TuiInput) -> Perhaps<bool> {
         match from.event() {
@@ -257,31 +214,6 @@ pub struct Sample {
 }
 
 impl Sample {
-    pub fn from_edn <'e> (dir: &str, args: &[Edn<'e>]) -> Usually<(Option<u7>, Arc<RwLock<Self>>)> {
-        let mut name = String::new();
-        let mut file = String::new();
-        let mut midi = None;
-        let mut start = 0usize;
-        edn!(edn in args {
-            Edn::Map(map) => {
-                if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
-                    name = String::from(*n);
-                }
-                if let Some(Edn::Str(f)) = map.get(&Edn::Key(":file")) {
-                    file = String::from(*f);
-                }
-                if let Some(Edn::Int(i)) = map.get(&Edn::Key(":start")) {
-                    start = *i as usize;
-                }
-                if let Some(Edn::Int(m)) = map.get(&Edn::Key(":midi")) {
-                    midi = Some(u7::from(*m as u8));
-                }
-            },
-            _ => panic!("unexpected in sample {name}"),
-        });
-        let (end, data) = read_sample_data(&format!("{dir}/{file}"))?;
-        Ok((midi, Arc::new(RwLock::new(Self::new(&name, start, end, data)))))
-    }
     pub fn new (name: &str, start: usize, end: usize, channels: Vec<Vec<f32>>) -> Self {
         Self { name: name.to_string(), start, end, channels, rate: None }
     }
@@ -615,3 +547,31 @@ impl Sample {
         Ok(sample)
     }
 }
+
+/// A currently playing instance of a sample.
+pub struct Voice {
+    pub sample:   Arc<RwLock<Sample>>,
+    pub after:    usize,
+    pub position: usize,
+    pub velocity: f32,
+}
+
+impl Iterator for Voice {
+    type Item = [f32;2];
+    fn next (&mut self) -> Option<Self::Item> {
+        if self.after > 0 {
+            self.after = self.after - 1;
+            return Some([0.0, 0.0])
+        }
+        let sample = self.sample.read().unwrap();
+        if self.position < sample.end {
+            let position = self.position;
+            self.position = self.position + 1;
+            return sample.channels[0].get(position).map(|_amplitude|[
+                sample.channels[0][position] * self.velocity,
+                sample.channels[0][position] * self.velocity,
+            ])
+        }
+        None
+    }
+}