mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-05-01 06:30:13 +02:00
202 lines
6.7 KiB
Rust
202 lines
6.7 KiB
Rust
use crate::*;
|
|
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};
|
|
|
|
/// 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),* })
|
|
}
|
|
};
|
|
}
|
|
|
|
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 {
|
|
($id:expr => |$context:tt:$Context:ty, $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
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
from_edn!("sampler" => |jack: &Arc<RwLock<JackClient>>, 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:?}")
|
|
});
|
|
Self::new(jack, &name)
|
|
});
|
|
|
|
type MidiSample = (Option<u7>, Arc<RwLock<crate::Sample>>);
|
|
|
|
from_edn!("sample" => |(_jack, dir): (&Arc<RwLock<JackClient>>, &str), 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,
|
|
gain: 1.0
|
|
}))))
|
|
});
|
|
|
|
from_edn!("plugin/lv2" => |jack: &Arc<RwLock<JackClient>>, args| -> 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)
|
|
});
|
|
|
|
const SYM_NAME: &str = ":name";
|
|
const SYM_GAIN: &str = ":gain";
|
|
const SYM_SAMPLER: &str = "sampler";
|
|
const SYM_LV2: &str = "lv2";
|
|
|
|
from_edn!("mixer/track" => |jack: &Arc<RwLock<JackClient>>, args| -> MixerTrack {
|
|
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(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.first() {
|
|
// Add a sampler device to the track
|
|
Some(Edn::Symbol(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.first().unwrap()
|
|
)
|
|
},
|
|
// Add a LV2 plugin to the track.
|
|
Some(Edn::Symbol(SYM_LV2)) => {
|
|
track.devices.push(
|
|
Box::new(Plugin::from_edn(jack, &args[1..])?) as Box<dyn MixerTrackDevice>
|
|
);
|
|
panic!(
|
|
"unsupported in track {}: {:?}; tek_mixer not compiled with feature \"plugin\"",
|
|
&track.name,
|
|
args.first().unwrap()
|
|
)
|
|
},
|
|
None =>
|
|
panic!("empty list track {}", &track.name),
|
|
_ =>
|
|
panic!("unexpected in track {}: {:?}", &track.name, args.first().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,
|
|
////})
|
|
////}
|
|
//}
|