wip: refactor into api and app

crates/tek_api/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "tek_api"
+edition = "2021"
+version = "0.1.0"
+
+[dependencies]
+tek_core = { path = "../tek_core" }
+uuid = { version = "1.10.0", features = [ "v4" ] }

crates/tek_api/examples/mixer.edn

@@ -0,0 +1,12 @@
+(mixer
+  (track
+    (name "Drums")
+    (sampler
+      (dir "/home/user/Lab/Music/pak")
+      (sample (midi 34) (name "808 D") (file "808.wav"))))
+  (track
+    (name "Lead")
+    (lv2
+      (name "Odin2")
+      (path "file:///home/user/.lv2/Odin2.lv2"))
+    (gain 0.0)))

crates/tek_api/examples/sequencer.edn

@@ -0,0 +1,18 @@
+(arranger
+  (track
+    (name "Drums")
+    (phrase
+      (name "4 kicks")
+      (beats 4)
+      (steps 16)
+      (:00 (36 128))
+      (:04 (36 100))
+      (:08 (36 100))
+      (:12 (36 100))))
+  (track
+    (name "Bass")
+    (phrase
+      (beats 4)
+      (steps 16)
+      (:04 (36 100))
+      (:12 (36 100)))))

crates/tek_api/src/api_cmd.rs

@@ -0,0 +1,143 @@
+use crate::*;
+
+#[derive(Clone)]
+pub enum ArrangerCommand {
+    Focus(FocusCommand),
+    Transport(TransportCommand),
+    Phrases(PhrasePoolCommand),
+    Editor(PhraseEditorCommand),
+    Arrangement(ArrangementCommand),
+    EditPhrase(Option<Arc<RwLock<Phrase>>>),
+}
+
+#[derive(Clone)]
+pub enum ArrangementCommand {
+    New,
+    Load,
+    Save,
+    ToggleViewMode,
+    Delete,
+    Activate,
+    Increment,
+    Decrement,
+    ZoomIn,
+    ZoomOut,
+    Go(Direction),
+    Edit(Option<Arc<RwLock<Phrase>>>),
+    Scene(SceneCommand),
+    Track(TrackCommand),
+    Clip(ClipCommand),
+}
+
+#[derive(Clone)]
+pub enum SceneCommand {
+    Next,
+    Prev,
+    Add,
+    Delete,
+    MoveForward,
+    MoveBack,
+    RandomColor,
+    SetSize(usize),
+    SetZoom(usize),
+}
+
+#[derive(Clone)]
+pub enum TrackCommand {
+    Next,
+    Prev,
+    Add,
+    Delete,
+    MoveForward,
+    MoveBack,
+    RandomColor,
+    SetSize(usize),
+    SetZoom(usize),
+}
+
+#[derive(Clone)]
+pub enum ClipCommand {
+    SetLoop(bool),
+    Get(usize, usize),
+    Put(usize, usize, Option<Arc<RwLock<Phrase>>>),
+    Edit(Option<Arc<RwLock<Phrase>>>),
+}
+
+#[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),
+}
+
+#[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),
+}

crates/tek_api/src/api_edn.rs

@@ -0,0 +1,158 @@
+use crate::*;
+
+impl Scene {
+    pub fn from_edn <'a, 'e> (args: &[Edn<'e>]) -> Usually<Self> {
+        let mut name  = None;
+        let mut clips = vec![];
+        edn!(edn in args {
+            Edn::Map(map) => {
+                let key = map.get(&Edn::Key(":name"));
+                if let Some(Edn::Str(n)) = key {
+                    name = Some(*n);
+                } else {
+                    panic!("unexpected key in scene '{name:?}': {key:?}")
+                }
+            },
+            Edn::Symbol("_") => {
+                clips.push(None);
+            },
+            Edn::Int(i) => {
+                clips.push(Some(*i as usize));
+            },
+            _ => panic!("unexpected in scene '{name:?}': {edn:?}")
+        });
+        let scene = Self::new(name.unwrap_or(""), clips);
+        Ok(scene)
+    }
+}
+
+const SYM_NAME:    &'static str = ":name";
+const SYM_GAIN:    &'static str = ":gain";
+const SYM_SAMPLER: &'static str = "sampler";
+const SYM_LV2:     &'static str = "lv2";
+
+impl<E: Engine> Track<E> {
+    pub fn from_edn <'a, 'e> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<Self> {
+        let mut _gain = 0.0f64;
+        let mut track = Self::new("")?;
+        #[allow(unused_mut)]
+        let mut devices: Vec<JackDevice<E>> = vec![];
+        edn!(edn in args {
+            Edn::Map(map) => {
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(SYM_NAME)) {
+                    track.name = n.to_string();
+                }
+                if let Some(Edn::Double(g)) = map.get(&Edn::Key(SYM_GAIN)) {
+                    _gain = f64::from(*g);
+                }
+            },
+            Edn::List(args) => match args.get(0) {
+                // Add a sampler device to the track
+                Some(Edn::Symbol(SYM_SAMPLER)) => {
+                    devices.push(Sampler::from_edn(jack, &args[1..])?);
+                    panic!(
+                        "unsupported in track {}: {:?}; tek_mixer not compiled with feature \"sampler\"",
+                        &track.name,
+                        args.get(0).unwrap()
+                    )
+                },
+                // Add a LV2 plugin to the track.
+                Some(Edn::Symbol(SYM_LV2)) => {
+                    devices.push(LV2Plugin::from_edn(jack, &args[1..])?);
+                    panic!(
+                        "unsupported in track {}: {:?}; tek_mixer not compiled with feature \"plugin\"",
+                        &track.name,
+                        args.get(0).unwrap()
+                    )
+                },
+                None =>
+                    panic!("empty list track {}", &track.name),
+                _ =>
+                    panic!("unexpected in track {}: {:?}", &track.name, args.get(0).unwrap())
+            },
+            _ => {}
+        });
+        for device in devices {
+            track.add_device(device);
+        }
+        Ok(track)
+    }
+}
+
+impl LV2Plugin {
+    pub fn from_edn <'e, E: Engine> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<JackDevice<E>> {
+        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<E: Engine> Sampler<E> {
+    pub fn from_edn <'e> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<JackDevice<E>> {
+        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(jack, &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(jack, &name, Some(samples))
+    }
+}
+
+impl Sample {
+    pub fn from_edn <'e> (jack: &Arc<RwLock<JackClient>>, 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)))))
+    }
+}

crates/tek_api/src/api_midi.rs

@@ -0,0 +1,28 @@
+use crate::*;
+pub(crate) use tek_core::midly::MidiMessage;
+
+/// MIDI message structural
+pub type PhraseData = Vec<Vec<MidiMessage>>;
+
+/// A MIDI sequence.
+#[derive(Debug, Clone)] pub struct Phrase {
+    pub uuid:        uuid::Uuid,
+    /// Name of phrase
+    pub name:        String,
+    /// Temporal resolution in pulses per quarter note
+    pub ppq:         usize,
+    /// Length of phrase in pulses
+    pub length:      usize,
+    /// Notes in phrase
+    pub notes:       PhraseData,
+    /// Whether to loop the phrase or play it once
+    pub loop_on:     bool,
+    /// Start of loop
+    pub loop_start:  usize,
+    /// Length of loop
+    pub loop_length: usize,
+    /// All notes are displayed with minimum length
+    pub percussive:  bool,
+    /// Identifying color of phrase
+    pub color:       ItemColorTriplet,
+}

crates/tek_api/src/lib.rs

@@ -0,0 +1,6 @@
+pub(crate) use tek_core::*;
+submod! {
+    api_cmd
+    api_edn
+    api_midi
+}