wip: refactor into crates

crates/tek_sampler/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "tek_sampler"
+edition = "2021"
+version = "0.1.0"
+
+[dependencies]
+tek_core = { path = "../tek_core" }
+tek_jack = { path = "../tek_jack" }
+symphonia = { version = "0.5.4", features = [ "all" ] }
+wavers = "1.4.3"

crates/tek_sampler/README.md

@@ -0,0 +1,4 @@
+# `tek_sampler`
+
+This crate implements a sampler device which plays audio files
+in response to MIDI notes.

crates/tek_sampler/src/lib.rs

@@ -0,0 +1,20 @@
+//! Sampler (currently 16bit WAVs at system rate; TODO convert/resample)
+
+pub(crate) use tek_core::*;
+pub(crate) use tek_core::ratatui::prelude::*;
+pub(crate) use tek_core::crossterm::event::{KeyCode, KeyModifiers};
+pub(crate) use tek_core::midly::{num::u7, live::LiveEvent, MidiMessage};
+pub(crate) use tek_jack::{*, jack::*};
+
+pub(crate) use std::collections::BTreeMap;
+pub(crate) use std::sync::{Arc, Mutex, RwLock};
+pub(crate) use std::path::PathBuf;
+pub(crate) use std::ffi::OsString;
+pub(crate) use std::fs::read_dir;
+
+submod! {
+    sampler
+    sample
+    sample_add
+    voice
+}

crates/tek_sampler/src/sample.rs

@@ -0,0 +1,54 @@
+use super::*;
+
+/// A sound sample.
+#[derive(Default, Debug)]
+pub struct Sample {
+    pub name:     String,
+    pub start:    usize,
+    pub end:      usize,
+    pub channels: Vec<Vec<f32>>,
+    pub rate:     Option<usize>,
+}
+
+impl Sample {
+    pub fn new (name: &str, start: usize, end: usize, channels: Vec<Vec<f32>>) -> Self {
+        Self { name: name.to_string(), start, end, channels, rate: None }
+    }
+    pub fn play (sample: &Arc<RwLock<Self>>, after: usize, velocity: &u7) -> Voice {
+        Voice {
+            sample: sample.clone(),
+            after,
+            position: sample.read().unwrap().start,
+            velocity: velocity.as_int() as f32 / 127.0,
+        }
+    }
+}
+
+
+/// Load sample from WAV and assign to MIDI note.
+#[macro_export] macro_rules! sample {
+    ($note:expr, $name:expr, $src:expr) => {{
+        let (end, data) = read_sample_data($src)?;
+        (
+            u7::from_int_lossy($note).into(),
+            Sample::new($name, 0, end, data).into()
+        )
+    }};
+}
+
+/// Read WAV from file
+pub fn read_sample_data (src: &str) -> Usually<(usize, Vec<Vec<f32>>)> {
+    let mut channels: Vec<wavers::Samples<f32>> = vec![];
+    for channel in wavers::Wav::from_path(src)?.channels() {
+        channels.push(channel);
+    }
+    let mut end = 0;
+    let mut data: Vec<Vec<f32>> = vec![];
+    for samples in channels.iter() {
+        let channel = Vec::from(samples.as_ref());
+        end = end.max(channel.len());
+        data.push(channel);
+    }
+    Ok((end, data))
+}
+

crates/tek_sampler/src/sample_add.rs

@@ -0,0 +1,279 @@
+use super::*;
+
+use std::fs::File;
+use symphonia::core::codecs::CODEC_TYPE_NULL;
+use symphonia::core::errors::Error;
+use symphonia::core::io::MediaSourceStream;
+use symphonia::core::probe::Hint;
+use symphonia::core::audio::SampleBuffer;
+use symphonia::default::get_codecs;
+
+pub struct AddSampleModal {
+    exited:  bool,
+    dir:     PathBuf,
+    subdirs: Vec<OsString>,
+    files:   Vec<OsString>,
+    cursor:  usize,
+    offset:  usize,
+    sample:  Arc<RwLock<Sample>>,
+    voices:  Arc<RwLock<Vec<Voice>>>,
+    _search: Option<String>,
+}
+
+exit!(AddSampleModal);
+
+render!(AddSampleModal |self,buf,area|{
+    make_dim(buf);
+    let area = center_box(
+        area,
+        64.max(area.width.saturating_sub(8)),
+        20.max(area.width.saturating_sub(8)),
+    );
+    fill_fg(buf, area, Color::Reset);
+    fill_bg(buf, area, Nord::bg_lo(true, true));
+    fill_char(buf, area, ' ');
+    format!("{}", &self.dir.to_string_lossy())
+        .blit(buf, area.x+2, area.y+1, Some(Style::default().bold()))?;
+    "Select sample:"
+        .blit(buf, area.x+2, area.y+2, Some(Style::default().bold()))?;
+    for (i, (is_dir, name)) in self.subdirs.iter()
+        .map(|path|(true, path))
+        .chain(self.files.iter().map(|path|(false, path)))
+        .enumerate()
+        .skip(self.offset)
+    {
+        if i >= area.height as usize - 4 {
+            break
+        }
+        let t = if is_dir { "" } else { "" };
+        let line = format!("{t} {}", name.to_string_lossy());
+        let line = &line[..line.len().min(area.width as usize - 4)];
+        line.blit(buf, area.x + 2, area.y + 3 + i as u16, Some(if i == self.cursor {
+            Style::default().green()
+        } else {
+            Style::default().white()
+        }))?;
+    }
+    Lozenge(Style::default()).draw(buf, area)
+});
+
+handle!(AddSampleModal |self,e|{
+    if handle_keymap(self, e, KEYMAP_ADD_SAMPLE)? {
+        return Ok(true)
+    }
+    Ok(true)
+});
+
+impl AddSampleModal {
+    pub fn new (
+        sample: &Arc<RwLock<Sample>>,
+        voices: &Arc<RwLock<Vec<Voice>>>
+    ) -> Usually<Self> {
+        let dir = std::env::current_dir()?;
+        let (subdirs, files) = scan(&dir)?;
+        Ok(Self {
+            exited: false,
+            dir,
+            subdirs,
+            files,
+            cursor: 0,
+            offset: 0,
+            sample: sample.clone(),
+            voices: voices.clone(),
+            _search: None
+        })
+    } 
+    fn rescan (&mut self) -> Usually<()> {
+        scan(&self.dir).map(|(subdirs, files)|{
+            self.subdirs = subdirs;
+            self.files = files;
+        })
+    }
+    fn prev (&mut self) {
+        self.cursor = self.cursor.saturating_sub(1);
+    }
+    fn next (&mut self) {
+        self.cursor = self.cursor + 1;
+    }
+    fn try_preview (&mut self) -> Usually<()> {
+        if let Some(path) = self.cursor_file() {
+            if let Ok(sample) = Sample::from_file(&path) {
+                *self.sample.write().unwrap() = sample;
+                self.voices.write().unwrap().push(
+                    Sample::play(&self.sample, 0, &u7::from(100u8))
+                );
+            }
+            //load_sample(&path)?;
+            //let src = std::fs::File::open(&path)?;
+            //let mss = MediaSourceStream::new(Box::new(src), Default::default());
+            //let mut hint = Hint::new();
+            //if let Some(ext) = path.extension() {
+                //hint.with_extension(&ext.to_string_lossy());
+            //}
+            //let meta_opts: MetadataOptions = Default::default();
+            //let fmt_opts: FormatOptions = Default::default();
+            //if let Ok(mut probed) =  symphonia::default::get_probe()
+                //.format(&hint, mss, &fmt_opts, &meta_opts)
+            //{
+                //panic!("{:?}", probed.format.metadata());
+            //};
+        }
+        Ok(())
+    }
+    fn cursor_dir (&self) -> Option<PathBuf> {
+        if self.cursor < self.subdirs.len() {
+            Some(self.dir.join(&self.subdirs[self.cursor]))
+        } else {
+            None
+        }
+    }
+    fn cursor_file (&self) -> Option<PathBuf> {
+        if self.cursor < self.subdirs.len() {
+            return None
+        }
+        let index = self.cursor.saturating_sub(self.subdirs.len());
+        if index < self.files.len() {
+            Some(self.dir.join(&self.files[index]))
+        } else {
+            None
+        }
+    }
+    fn pick (&mut self) -> Usually<bool> {
+        if self.cursor == 0 {
+            if let Some(parent) = self.dir.parent() {
+                self.dir = parent.into();
+                self.rescan()?;
+                self.cursor = 0;
+                return Ok(false)
+            }
+        }
+        if let Some(dir) = self.cursor_dir() {
+            self.dir = dir;
+            self.rescan()?;
+            self.cursor = 0;
+            return Ok(false)
+        }
+        if let Some(path) = self.cursor_file() {
+            let (end, channels) = read_sample_data(&path.to_string_lossy())?;
+            let mut sample = self.sample.write().unwrap();
+            sample.name = path.file_name().unwrap().to_string_lossy().into();
+            sample.end = end;
+            sample.channels = channels;
+            return Ok(true)
+        }
+        return Ok(false)
+    }
+}
+
+pub const KEYMAP_ADD_SAMPLE: &'static [KeyBinding<AddSampleModal>] = keymap!(AddSampleModal {
+    [Esc,   NONE, "sampler/add/close", "close help dialog",       |modal: &mut AddSampleModal|{
+        modal.exit();
+        Ok(true)
+    }],
+    [Up,    NONE, "sampler/add/prev",  "select previous entry",   |modal: &mut AddSampleModal|{
+        modal.prev();
+        Ok(true)
+    }],
+    [Down,  NONE, "sampler/add/next",  "select next entry",       |modal: &mut AddSampleModal|{
+        modal.next();
+        Ok(true)
+    }],
+    [Enter, NONE, "sampler/add/enter", "activate selected entry", |modal: &mut AddSampleModal|{
+        if modal.pick()? {
+            modal.exit();
+        }
+        Ok(true)
+    }],
+    [Char('p'), NONE, "sampler/add/preview", "preview selected entry", |modal: &mut AddSampleModal|{
+        modal.try_preview()?;
+        Ok(true)
+    }]
+});
+
+fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
+    let (mut subdirs, mut files) = read_dir(dir)?
+        .fold((vec!["..".into()], vec![]), |(mut subdirs, mut files), entry|{
+            let entry = entry.expect("failed to read drectory entry");
+            let meta = entry.metadata().expect("failed to read entry metadata");
+            if meta.is_file() {
+                files.push(entry.file_name());
+            } else if meta.is_dir() {
+                subdirs.push(entry.file_name());
+            }
+            (subdirs, files)
+        });
+    subdirs.sort();
+    files.sort();
+    Ok((subdirs, files))
+}
+
+impl Sample {
+    fn from_file (path: &PathBuf) -> Usually<Self> {
+        let mut sample = Self::default();
+        sample.name = path.file_name().unwrap().to_string_lossy().into();
+        // Use file extension if present
+        let mut hint = Hint::new();
+        if let Some(ext) = path.extension() {
+            hint.with_extension(&ext.to_string_lossy());
+        }
+        let probed = symphonia::default::get_probe().format(
+            &hint,
+            MediaSourceStream::new(
+                Box::new(File::open(path)?),
+                Default::default(),
+            ),
+            &Default::default(),
+            &Default::default()
+        )?;
+        let mut format = probed.format;
+        let mut decoder = get_codecs().make(
+            &format.tracks().iter()
+                .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
+                .expect("no tracks found")
+                .codec_params,
+            &Default::default()
+        )?;
+        loop {
+            match format.next_packet() {
+                Ok(packet) => {
+                    // Decode a packet
+                    let decoded = match decoder.decode(&packet) {
+                        Ok(decoded) => decoded,
+                        Err(err) => { return Err(err.into()); }
+                    };
+                    // Determine sample rate
+                    let spec = *decoded.spec();
+                    if let Some(rate) = sample.rate {
+                        if rate != spec.rate as usize {
+                            panic!("sample rate changed");
+                        }
+                    } else {
+                        sample.rate = Some(spec.rate as usize);
+                    }
+                    // Determine channel count
+                    while sample.channels.len() < spec.channels.count() {
+                        sample.channels.push(vec![]);
+                    }
+                    // Load sample
+                    let mut samples = SampleBuffer::new(
+                        decoded.frames() as u64,
+                        spec
+                    );
+                    if samples.capacity() > 0 {
+                        samples.copy_interleaved_ref(decoded);
+                        for frame in samples.samples().chunks(spec.channels.count()) {
+                            for (chan, frame) in frame.iter().enumerate() {
+                                sample.channels[chan].push(*frame)
+                            }
+                        }
+                    }
+                },
+                Err(Error::IoError(_)) => break decoder.last_decoded(),
+                Err(err) => return Err(err.into()),
+            };
+        };
+        sample.end = sample.channels.iter().fold(0, |l, c|l + c.len());
+        Ok(sample)
+    }
+}
+

crates/tek_sampler/src/sampler.rs

@@ -0,0 +1,199 @@
+use crate::*;
+
+/// The sampler plugin plays sounds.
+pub struct Sampler {
+    pub name:        String,
+    pub cursor:      (usize, usize),
+    pub editing:     Option<Arc<RwLock<Sample>>>,
+    pub mapped:      BTreeMap<u7, Arc<RwLock<Sample>>>,
+    pub unmapped:    Vec<Arc<RwLock<Sample>>>,
+    pub voices:      Arc<RwLock<Vec<Voice>>>,
+    pub ports:       JackPorts,
+    pub buffer:      Vec<Vec<f32>>,
+    pub modal:       Arc<Mutex<Option<Box<dyn Exit + Send>>>>,
+    pub output_gain: f32
+}
+
+render!(Sampler |self, buf, area| {
+    let Rect { x, y, height, .. } = area;
+    let style = Style::default().gray();
+    let title = format!(" {} ({})", self.name, self.voices.read().unwrap().len());
+    title.blit(buf, x+1, y, Some(style.white().bold().not_dim()))?;
+    let mut width = title.len() + 2;
+    let mut y1 = 1;
+    let mut j = 0;
+    for (note, sample) in self.mapped.iter()
+        .map(|(note, sample)|(Some(note), sample))
+        .chain(self.unmapped.iter().map(|sample|(None, sample)))
+    {
+        if y1 >= height {
+            break
+        }
+        let active = j == self.cursor.0;
+        width = width.max(draw_sample(buf, x, y + y1, note, &*sample.read().unwrap(), active)?);
+        y1 = y1 + 1;
+        j = j + 1;
+    }
+    let height = ((2 + y1) as u16).min(height);
+    Ok(Rect { x, y, width: (width as u16).min(area.width), height })
+});
+
+fn draw_sample (
+    buf: &mut Buffer, x: u16, y: u16, note: Option<&u7>, sample: &Sample, focus: bool
+) -> Usually<usize> {
+    let style = if focus { Style::default().green() } else { Style::default() };
+    if focus {
+        "🬴".blit(buf, x+1, y, Some(style.bold()))?;
+    }
+    let label1 = format!("{:3} {:12}",
+        note.map(|n|n.to_string()).unwrap_or(String::default()),
+        sample.name);
+    let label2 = format!("{:>6} {:>6}  +0.0",
+        sample.start,
+        sample.end);
+    label1.blit(buf, x+2, y, Some(style.bold()))?;
+    label2.blit(buf, x+3+label1.len()as u16, y, Some(style))?;
+    Ok(label1.len() + label2.len() + 4)
+}
+
+handle!(Sampler |self, event| handle_keymap(self, event, KEYMAP_SAMPLER));
+
+/// Key bindings for sampler device.
+pub const KEYMAP_SAMPLER: &'static [KeyBinding<Sampler>] = keymap!(Sampler {
+    [Up, NONE, "/sampler/cursor/up", "move cursor up", |state: &mut Sampler| {
+        state.cursor.0 = if state.cursor.0 == 0 {
+            state.mapped.len() + state.unmapped.len() - 1
+        } else {
+            state.cursor.0 - 1
+        };
+        Ok(true)
+    }],
+    [Down, NONE, "/sampler/cursor/down", "move cursor down", |state: &mut Sampler| {
+        state.cursor.0 = (state.cursor.0 + 1) % (state.mapped.len() + state.unmapped.len());
+        Ok(true)
+    }],
+    [Char('p'), NONE, "/sampler/play", "play current sample",  |state: &mut Sampler| {
+        if let Some(sample) = state.sample() {
+            state.voices.write().unwrap().push(Sample::play(sample, 0, &100.into()));
+        }
+        Ok(true)
+    }],
+    [Char('a'), NONE, "/sampler/add", "add a new sample", |state: &mut Sampler| {
+        let sample = Arc::new(RwLock::new(Sample::new("", 0, 0, vec![])));
+        *state.modal.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample, &state.voices)?));
+        state.unmapped.push(sample);
+        Ok(true)
+    }],
+    [Char('r'), NONE, "/sampler/replace", "replace selected sample", |state: &mut Sampler| {
+        if let Some(sample) = state.sample() {
+            *state.modal.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample, &state.voices)?));
+        }
+        Ok(true)
+    }],
+    [Enter, NONE, "/sampler/edit", "edit selected sample", |state: &mut Sampler| {
+        if let Some(sample) = state.sample() {
+            state.editing = Some(sample.clone());
+        }
+        Ok(true)
+    }],
+});
+
+process!(Sampler = Sampler::process);
+
+impl Sampler {
+    pub fn new (name: &str, mapped: Option<BTreeMap<u7, Arc<RwLock<Sample>>>>) -> Usually<JackDevice> {
+        Jack::new(name)?
+            .midi_in("midi")
+            .audio_in("recL")
+            .audio_in("recR")
+            .audio_out("outL")
+            .audio_out("outR")
+            .run(|ports|Box::new(Self {
+                name:     name.into(),
+                cursor:   (0, 0),
+                editing:  None,
+                mapped:   mapped.unwrap_or_else(||BTreeMap::new()),
+                unmapped: vec![],
+                voices:   Arc::new(RwLock::new(vec![])),
+                ports,
+                buffer:   vec![vec![0.0;16384];2],
+                output_gain: 0.5,
+                modal:    Default::default()
+            }))
+    }
+
+    /// 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
+    }
+
+    pub fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        self.process_midi_in(scope);
+        self.clear_output_buffer();
+        self.process_audio_out(scope);
+        self.write_output_buffer(scope);
+        Control::Continue
+    }
+
+    /// Create [Voice]s from [Sample]s in response to MIDI input.
+    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.
+    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.
+    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.
+    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_sampler/src/voice.rs

@@ -0,0 +1,29 @@
+use super::*;
+
+/// A currently playing instance of a sample.
+pub struct Voice {
+    pub sample:   Arc<RwLock<Sample>>,
+    pub after:    usize,
+    pub position: usize,
+    pub velocity: f32,
+}
+
+impl Iterator for Voice {
+    type Item = [f32;2];
+    fn next (&mut self) -> Option<Self::Item> {
+        if self.after > 0 {
+            self.after = self.after - 1;
+            return Some([0.0, 0.0])
+        }
+        let sample = self.sample.read().unwrap();
+        if self.position < sample.end {
+            let position = self.position;
+            self.position = self.position + 1;
+            return sample.channels[0].get(position).map(|_amplitude|[
+                sample.channels[0][position] * self.velocity,
+                sample.channels[0][position] * self.velocity,
+            ])
+        }
+        None
+    }
+}