wip: refactor pt.5, no translate

crates/tek_api/src/api_cmd.rs

@@ -1,66 +1 @@
 use crate::*;
-
-#[derive(Clone, PartialEq)]
-pub enum SequencerCommand {
-    Focus(FocusCommand),
-    Transport(TransportCommand),
-    Phrases(PhrasePoolCommand),
-    Editor(PhraseEditorCommand),
-}
-
-#[derive(Clone, PartialEq)]
-pub enum PhrasePoolCommand {
-    Prev,
-    Next,
-    MoveUp,
-    MoveDown,
-    Delete,
-    Append,
-    Insert,
-    Duplicate,
-    RandomColor,
-    Edit,
-    Import,
-    Export,
-    Rename(PhraseRenameCommand),
-    Length(PhraseLengthCommand),
-}
-
-#[derive(Clone, PartialEq)]
-pub enum PhraseRenameCommand {
-    Begin,
-    Backspace,
-    Append(char),
-    Set(String),
-    Confirm,
-    Cancel,
-}
-
-#[derive(Clone, PartialEq)]
-pub enum PhraseLengthCommand {
-    Begin,
-    Next,
-    Prev,
-    Inc,
-    Dec,
-    Set(usize),
-    Confirm,
-    Cancel,
-}
-
-#[derive(Clone, PartialEq)]
-pub enum PhraseEditorCommand {
-    // TODO: 1-9 seek markers that by default start every 8th of the phrase
-    ToggleDirection,
-    EnterEditMode,
-    ExitEditMode,
-    NoteAppend,
-    NoteSet,
-    NoteCursorSet(usize),
-    NoteLengthSet(usize),
-    NoteScrollSet(usize),
-    TimeCursorSet(usize),
-    TimeScrollSet(usize),
-    TimeZoomSet(usize),
-    Go(Direction),
-}

crates/tek_api/src/lib.rs

@@ -1,21 +1,27 @@
 pub(crate) use tek_core::*;
-pub(crate) use tek_core::jack::*;
 pub(crate) use tek_core::midly::{*, live::LiveEvent, num::u7};
 pub(crate) use std::thread::JoinHandle;
 pub(crate) use std::fmt::{Debug, Formatter, Error};
+pub(crate) use tek_core::jack::{
+    Client, ProcessScope, Control, CycleTimes,
+    Port, MidiIn, MidiOut, AudioIn, AudioOut, Unowned,
+    TransportState, MidiIter, RawMidi
+};
 
 submod! {
     clock
     mixer
     phrase
     plugin
+    plugin_kind
+    plugin_lv2
     pool
     sampler
     sample
     scene
     sequencer
     track
-    transport
+    transport transport_cmd
     voice
 
     api_cmd

crates/tek_api/src/phrase.rs

@@ -1,7 +1,7 @@
 use crate::*;
 
 /// A MIDI sequence.
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct Phrase {
     pub uuid:        uuid::Uuid,
     /// Name of phrase
@@ -74,5 +74,11 @@ impl Default for Phrase {
         Self::new("(empty)", false, 0, None, Some(ItemColor::from(Color::Rgb(0, 0, 0)).into()))
     }
 }
-impl PartialEq for Phrase { fn eq (&self, other: &Self) -> bool { self.uuid == other.uuid } }
+
+impl PartialEq for Phrase {
+    fn eq (&self, other: &Self) -> bool {
+        self.uuid == other.uuid
+    }
+}
+
 impl Eq for Phrase {}

crates/tek_api/src/plugin.rs

@@ -46,91 +46,6 @@ impl Plugin {
     //}
 }
 
-/// Supported plugin formats.
-#[derive(Default)]
-pub enum PluginKind {
-    #[default] None,
-    LV2(LV2Plugin),
-    VST2 { instance: ::vst::host::PluginInstance },
-    VST3,
-}
-impl Debug for PluginKind {
-    fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{}", match self {
-            Self::None     => "(none)",
-            Self::LV2(_)   => "LV2",
-            Self::VST2{..} => "VST2",
-            Self::VST3     => "VST3",
-        })
-    }
-}
-
-/// A LV2 plugin.
-#[derive(Debug)]
-pub struct LV2Plugin {
-    pub world:        livi::World,
-    pub instance:     livi::Instance,
-    pub plugin:       livi::Plugin,
-    pub features:     Arc<livi::Features>,
-    pub port_list:    Vec<livi::Port>,
-    pub input_buffer: Vec<livi::event::LV2AtomSequence>,
-    pub ui_thread:    Option<JoinHandle<()>>,
-}
-
-impl LV2Plugin {
-    const INPUT_BUFFER: usize = 1024;
-    pub fn new (uri: &str) -> Usually<Self> {
-        let world = livi::World::with_load_bundle(&uri);
-        let features = world
-            .build_features(livi::FeaturesBuilder {
-                min_block_length: 1,
-                max_block_length: 65536,
-            });
-        let plugin = world
-            .iter_plugins()
-            .nth(0)
-            .expect(&format!("plugin not found: {uri}"));
-        Ok(Self {
-            instance: unsafe {
-                plugin
-                    .instantiate(features.clone(), 48000.0)
-                    .expect(&format!("instantiate failed: {uri}"))
-            },
-            port_list: plugin.ports().collect::<Vec<_>>(),
-            input_buffer: Vec::with_capacity(Self::INPUT_BUFFER),
-            ui_thread: None,
-            world,
-            features,
-            plugin,
-        })
-    }
-}
-
-impl LV2Plugin {
-    pub fn from_edn <'e> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<Self> {
-        let mut name = String::new();
-        let mut path = String::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(p)) = map.get(&Edn::Key(":path")) {
-                    path = String::from(*p);
-                }
-            },
-            _ => panic!("unexpected in lv2 '{name}'"),
-        });
-        Plugin::new_lv2(jack, &name, &path)
-    }
-}
-
-impl Audio for LV2Plugin {
-    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
-        Control::Continue
-    }
-}
-
 impl Audio for Plugin {
     fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
         match self.plugin.as_mut() {

crates/tek_api/src/plugin_kind.rs

@@ -0,0 +1,21 @@
+use crate::*;
+
+/// Supported plugin formats.
+#[derive(Default)]
+pub enum PluginKind {
+    #[default] None,
+    LV2(LV2Plugin),
+    VST2 { instance: ::vst::host::PluginInstance },
+    VST3,
+}
+
+impl Debug for PluginKind {
+    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), Error> {
+        write!(f, "{}", match self {
+            Self::None     => "(none)",
+            Self::LV2(_)   => "LV2",
+            Self::VST2{..} => "VST2",
+            Self::VST3     => "VST3",
+        })
+    }
+}

crates/tek_api/src/plugin_lv2.rs

@@ -0,0 +1,67 @@
+use crate::*;
+
+/// A LV2 plugin.
+#[derive(Debug)]
+pub struct LV2Plugin {
+    pub world:        livi::World,
+    pub instance:     livi::Instance,
+    pub plugin:       livi::Plugin,
+    pub features:     Arc<livi::Features>,
+    pub port_list:    Vec<livi::Port>,
+    pub input_buffer: Vec<livi::event::LV2AtomSequence>,
+    pub ui_thread:    Option<JoinHandle<()>>,
+}
+
+impl LV2Plugin {
+    const INPUT_BUFFER: usize = 1024;
+    pub fn new (uri: &str) -> Usually<Self> {
+        let world = livi::World::with_load_bundle(&uri);
+        let features = world
+            .build_features(livi::FeaturesBuilder {
+                min_block_length: 1,
+                max_block_length: 65536,
+            });
+        let plugin = world
+            .iter_plugins()
+            .nth(0)
+            .expect(&format!("plugin not found: {uri}"));
+        Ok(Self {
+            instance: unsafe {
+                plugin
+                    .instantiate(features.clone(), 48000.0)
+                    .expect(&format!("instantiate failed: {uri}"))
+            },
+            port_list: plugin.ports().collect::<Vec<_>>(),
+            input_buffer: Vec::with_capacity(Self::INPUT_BUFFER),
+            ui_thread: None,
+            world,
+            features,
+            plugin,
+        })
+    }
+}
+
+impl LV2Plugin {
+    pub fn from_edn <'e> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<Self> {
+        let mut name = String::new();
+        let mut path = String::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(p)) = map.get(&Edn::Key(":path")) {
+                    path = String::from(*p);
+                }
+            },
+            _ => panic!("unexpected in lv2 '{name}'"),
+        });
+        Plugin::new_lv2(jack, &name, &path)
+    }
+}
+
+impl Audio for LV2Plugin {
+    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        Control::Continue
+    }
+}

crates/tek_api/src/pool.rs

@@ -2,16 +2,48 @@ use crate::*;
 
 /// Contains all phrases in a project
 pub struct PhrasePool {
-    /// Scroll offset
-    pub scroll:  usize,
-    /// Highlighted phrase
-    pub phrase:  usize,
     /// Phrases in the pool
     pub phrases: Vec<Arc<RwLock<Phrase>>>,
-    /// Mode switch
-    pub mode:    Option<PhrasePoolMode>,
-    /// Whether this widget is focused
-    pub focused: bool,
-    /// Whether this widget is entered
-    pub entered: bool,
+    /// Highlighted phrase
+    pub phrase:  usize,
+}
+
+#[derive(Clone, PartialEq)]
+pub enum PhrasePoolCommand {
+    Prev,
+    Next,
+    MoveUp,
+    MoveDown,
+    Delete,
+    Append,
+    Insert,
+    Duplicate,
+    RandomColor,
+    Edit,
+    Import,
+    Export,
+    Rename(PhraseRenameCommand),
+    Length(PhraseLengthCommand),
+}
+
+#[derive(Clone, PartialEq)]
+pub enum PhraseRenameCommand {
+    Begin,
+    Backspace,
+    Append(char),
+    Set(String),
+    Confirm,
+    Cancel,
+}
+
+#[derive(Clone, PartialEq)]
+pub enum PhraseLengthCommand {
+    Begin,
+    Next,
+    Prev,
+    Inc,
+    Dec,
+    Set(usize),
+    Confirm,
+    Cancel,
 }

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);
+            }
+        }
+    }
 }

crates/tek_api/src/sequencer.rs

@@ -1,6 +1,29 @@
 use crate::*;
 
-pub enum SequencerCommand {}
+#[derive(Clone, PartialEq)]
+pub enum SequencerCommand {
+    Focus(FocusCommand),
+    Transport(TransportCommand),
+    Phrases(PhrasePoolCommand),
+    Editor(PhraseEditorCommand),
+}
+
+#[derive(Clone, PartialEq)]
+pub enum PhraseEditorCommand {
+    // TODO: 1-9 seek markers that by default start every 8th of the phrase
+    ToggleDirection,
+    EnterEditMode,
+    ExitEditMode,
+    NoteAppend,
+    NoteSet,
+    NoteCursorSet(usize),
+    NoteLengthSet(usize),
+    NoteScrollSet(usize),
+    TimeCursorSet(usize),
+    TimeScrollSet(usize),
+    TimeZoomSet(usize),
+    Go(Direction),
+}
 
 #[derive(Debug)]
 pub struct SequencerTrack {

crates/tek_api/src/transport.rs

@@ -1,19 +1,5 @@
 use crate::*;
 
-#[derive(Copy, Clone, PartialEq)]
-pub enum TransportCommand {
-    FocusNext,
-    FocusPrev,
-    Play(Option<usize>),
-    Pause(Option<usize>),
-    SeekUsec(f64),
-    SeekSample(f64),
-    SeekPulse(f64),
-    SetBpm(f64),
-    SetQuant(f64),
-    SetSync(f64),
-}
-
 pub struct Transport {
     pub jack:      Arc<RwLock<JackClient>>,
     /// JACK transport handle.

crates/tek_api/src/transport_cmd.rs

@@ -0,0 +1,31 @@
+use crate::*;
+
+#[derive(Copy, Clone, PartialEq)]
+pub enum TransportCommand {
+    Play(Option<usize>),
+    Pause(Option<usize>),
+    SeekUsec(f64),
+    SeekSample(f64),
+    SeekPulse(f64),
+    SetBpm(f64),
+    SetQuant(f64),
+    SetSync(f64),
+}
+
+impl Command<Transport> for TransportCommand {
+    fn execute (self, state: &mut Transport) -> Perhaps<Self> {
+        use TransportCommand::*;
+        match self.translate(&state) {
+            Play(start)        => {todo!()},
+            Pause(start)       => {todo!()},
+            SeekUsec(usec)     => {state.clock.current.update_from_usec(usec);},
+            SeekSample(sample) => {state.clock.current.update_from_sample(sample);},
+            SeekPulse(pulse)   => {state.clock.current.update_from_pulse(pulse);},
+            SetBpm(bpm)        => {return Ok(Some(Self::SetBpm(state.clock.timebase().bpm.set(bpm))))},
+            SetQuant(quant)    => {return Ok(Some(Self::SetQuant(state.clock.quant.set(quant))))},
+            SetSync(sync)      => {return Ok(Some(Self::SetSync(state.clock.sync.set(sync))))},
+            _ => { unreachable!() }
+        }
+        Ok(None)
+    }
+}

crates/tek_api/src/voice.rs

@@ -0,0 +1,10 @@
+use crate::*;
+
+/// 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,
+}