wip: multi-crate refactor

crates/edn/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name    = "tek_edn"
+edition = "2021"
+version = "0.2.0"
+
+[dependencies]
+tek = { path = "../tek" }
+clojure-reader = "0.1.0"

crates/edn/src/lib.rs

@@ -0,0 +1,215 @@
+use tek::{*, jack::*};
+use std::sync::{Arc, RwLock};
+use std::collections::BTreeMap;
+
+pub use clojure_reader::edn::Edn;
+//pub use clojure_reader::{edn::{read, Edn}, error::Error as EdnError};
+
+pub trait FromEdn<C>: Sized {
+    const ID: &'static str;
+    fn from_edn (context: C, expr: &[Edn<'_>]) -> Usually<Self>;
+}
+
+/// Implements the [FromEdn] trait.
+#[macro_export] macro_rules! from_edn {
+    (|$context:pat = $Context:ty, $id:expr, $args:ident| -> $T:ty $body:block) => {
+        impl FromEdn<$Context> for $T {
+            const ID: &'static str = $id;
+            fn from_edn <'e> ($context: $Context, $args: &[Edn<'e>]) -> Usually<Self> {
+                $body
+            }
+        }
+    }
+}
+
+/// EDN parsing helper.
+#[macro_export] macro_rules! edn {
+    ($edn:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
+        match $edn { $($pat => $expr),* }
+    };
+    ($edn:ident in $args:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
+        for $edn in $args {
+            edn!($edn { $($pat => $expr),* })
+        }
+    };
+}
+
+from_edn!(|jack = &Arc<RwLock<JackClient>>, "sampler", args| -> crate::Sampler {
+    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.first() {
+            Some(Edn::Symbol("sample")) => {
+                let (midi, sample) = MidiSample::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:?}")
+    });
+    let midi_in = jack.read().unwrap().client().register_port("in", MidiIn::default())?;
+    Ok(Self {
+        jack:        jack.clone(),
+        mapped:      samples,
+        unmapped:    Default::default(),
+        voices:      Default::default(),
+        buffer:      Default::default(),
+        audio_outs:  vec![],
+        output_gain: 0.,
+        midi_in,
+        name,
+    })
+});
+
+type MidiSample = (Option<u7>, Arc<RwLock<crate::Sample>>);
+
+from_edn!(|(jack, dir) = (&Arc<RwLock<JackClient>>, &str), "sample", args| -> MidiSample {
+    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) = Sample::read_data(&format!("{dir}/{file}"))?;
+    Ok((midi, Arc::new(RwLock::new(crate::Sample {
+        name,
+        start,
+        end,
+        channels: data,
+        rate: None
+    }))))
+});
+
+impl LV2Plugin {
+    pub fn from_edn <'e> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<Plugin> {
+        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 MixerTrack {
+    const SYM_NAME:    &'static str = ":name";
+    const SYM_GAIN:    &'static str = ":gain";
+    const SYM_SAMPLER: &'static str = "sampler";
+    const SYM_LV2:     &'static str = "lv2";
+    pub fn from_edn <'a, 'e> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<Self> {
+        let mut _gain = 0.0f64;
+        let mut track = MixerTrack {
+            name:       String::new(),
+            audio_ins:  vec![],
+            audio_outs: vec![],
+            devices:    vec![],
+        };
+        edn!(edn in args {
+            Edn::Map(map) => {
+                if let Some(Edn::Str(n)) = map.get(&Edn::Key(Self::SYM_NAME)) {
+                    track.name = n.to_string();
+                }
+                if let Some(Edn::Double(g)) = map.get(&Edn::Key(Self::SYM_GAIN)) {
+                    _gain = f64::from(*g);
+                }
+            },
+            Edn::List(args) => match args.get(0) {
+                // Add a sampler device to the track
+                Some(Edn::Symbol(Self::SYM_SAMPLER)) => {
+                    track.devices.push(
+                        Box::new(Sampler::from_edn(jack, &args[1..])?) as Box<dyn MixerTrackDevice>
+                    );
+                    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(Self::SYM_LV2)) => {
+                    track.devices.push(
+                        Box::new(LV2Plugin::from_edn(jack, &args[1..])?) as Box<dyn MixerTrackDevice>
+                    );
+                    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())
+            },
+            _ => {}
+        });
+        Ok(track)
+    }
+}
+
+//impl ArrangerScene {
+
+    ////TODO
+    ////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:?}")
+        ////});
+        ////Ok(ArrangerScene {
+            ////name:  Arc::new(name.unwrap_or("").to_string().into()),
+            ////color: ItemColor::random(),
+            ////clips,
+        ////})
+    ////}
+//}