tek/crates/tek_api/src/api_edn.rs

use crate::*;
use crate::midly::num::u7;

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


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 = Self::new("")?;
        #[allow(unused_mut)]
        let mut devices: Vec<JackDevice> = 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)) => {
                    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(Self::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> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<JackDevice> {
        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 Sampler {
    pub fn from_edn <'e> (jack: &Arc<RwLock<JackClient>>, args: &[Edn<'e>]) -> Usually<JackDevice> {
        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)))))
    }
}