flatten workspace into 1 crate

src/sampler/sample.rs

@@ -0,0 +1,121 @@
+use crate::*;
+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>,
+    pub gain:     f32,
+}
+
+/// 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()
+        )
+    }};
+}
+
+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, gain: 1.0 }
+    }
+    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,
+        }
+    }
+    /// Read WAV from file
+    pub fn read_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))
+    }
+    pub fn from_file (path: &PathBuf) -> Usually<Self> {
+        let name = path.file_name().unwrap().to_string_lossy().into();
+        let mut sample = Self { name, ..Default::default() };
+        // 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 params = &format.tracks().iter()
+            .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
+            .expect("no tracks found")
+            .codec_params;
+        let mut decoder = get_codecs().make(params, &Default::default())?;
+        loop {
+            match format.next_packet() {
+                Ok(packet) => sample.decode_packet(&mut decoder, packet)?,
+                Err(symphonia::core::errors::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)
+    }
+    fn decode_packet (
+        &mut self, decoder: &mut Box<dyn Decoder>, packet: Packet
+    ) -> Usually<()> {
+        // Decode a packet
+        let decoded = decoder
+            .decode(&packet)
+            .map_err(|e|Box::<dyn crate::Error>::from(e))?;
+        // Determine sample rate
+        let spec = *decoded.spec();
+        if let Some(rate) = self.rate {
+            if rate != spec.rate as usize {
+                panic!("sample rate changed");
+            }
+        } else {
+            self.rate = Some(spec.rate as usize);
+        }
+        // Determine channel count
+        while self.channels.len() < spec.channels.count() {
+            self.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() {
+                    self.channels[chan].push(*frame)
+                }
+            }
+        }
+        Ok(())
+    }
+}

src/sampler/sample_import.rs

@@ -0,0 +1,246 @@
+use crate::*;
+use super::*;
+
+input_to_command!(FileBrowserCommand:<Tui>|state:SamplerTui,input|match input {
+    _ => return None
+});
+
+command!(|self:FileBrowserCommand,state:SamplerTui|match self {
+    _ => todo!()
+});
+
+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>,
+}
+
+impl Exit for AddSampleModal {
+    fn exited (&self) -> bool {
+        self.exited
+    }
+    fn exit (&mut self) {
+        self.exited = 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)
+    }
+}
+
+fn read_sample_data (_: &str) -> Usually<(usize, Vec<Vec<f32>>)> {
+    todo!();
+}
+
+fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
+    let (mut subdirs, mut files) = std::fs::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))
+}
+
+fn draw_sample (
+    to: &mut TuiOutput, 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 {
+        to.blit(&"🬴", 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);
+    to.blit(&label1, x+2, y, Some(style.bold()));
+    to.blit(&label2, x+3+label1.len()as u16, y, Some(style));
+    Ok(label1.len() + label2.len() + 4)
+}
+
+impl Render<Tui> for AddSampleModal {
+    fn min_size (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
+        todo!()
+        //Align::Center(()).layout(to)
+    }
+    fn render (&self, to: &mut TuiOutput) -> Usually<()> {
+        todo!()
+        //let area = to.area();
+        //to.make_dim();
+        //let area = center_box(
+            //area,
+            //64.max(area.w().saturating_sub(8)),
+            //20.max(area.w().saturating_sub(8)),
+        //);
+        //to.fill_fg(area, Color::Reset);
+        //to.fill_bg(area, Nord::bg_lo(true, true));
+        //to.fill_char(area, ' ');
+        //to.blit(&format!("{}", &self.dir.to_string_lossy()), area.x()+2, area.y()+1, Some(Style::default().bold()))?;
+        //to.blit(&"Select sample:", 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.h() 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.w() as usize - 4)];
+            //to.blit(&line, 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(to)
+    }
+}
+
+//impl Handle<Tui> for AddSampleModal {
+    //fn handle (&mut self, from: &TuiInput) -> Perhaps<bool> {
+        //if from.handle_keymap(self, KEYMAP_ADD_SAMPLE)? {
+            //return Ok(Some(true))
+        //}
+        //Ok(Some(true))
+    //}
+//}
+
+//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)
+    //}]
+//});

src/sampler/sample_viewer.rs

@@ -0,0 +1,52 @@
+use crate::*;
+use std::ops::Deref;
+use ratatui::{prelude::Rect, widgets::{Widget, canvas::{Canvas, Points, Line}}};
+
+const EMPTY: &[(f64, f64)] = &[(0., 0.), (1., 1.), (2., 2.), (0., 2.), (2., 0.)];
+
+pub struct SampleViewer(pub Option<Arc<RwLock<Sample>>>);
+render!(<Tui>|self: SampleViewer|render(|to|{
+    let [x, y, width, height] = to.area();
+    let area = Rect { x, y, width, height };
+    let min_db = -40.0;
+    let (x_bounds, y_bounds, lines): ([f64;2], [f64;2], Vec<Line>) =
+        if let Some(sample) = &self.0 {
+            let sample = sample.read().unwrap();
+            let start  = sample.start  as f64;
+            let end    = sample.end    as f64;
+            let length = end - start;
+            let step   = length / width as f64;
+            let mut t = start;
+            let mut lines = vec![];
+            while t < end {
+                let chunk = &sample.channels[0][t as usize..((t + step) as usize).min(sample.end)];
+                let total: f32 = chunk.iter().map(|x|x.abs()).sum();
+                let count = chunk.len() as f32;
+                let meter = 10. * (total / count).log10();
+                let x = t as f64;
+                let y = meter as f64;
+                lines.push(Line::new(x, min_db, x, y, Color::Green));
+                t += step / 2.;
+            }
+            (
+                [sample.start as f64, sample.end as f64],
+                [min_db, 0.],
+                lines
+            )
+        } else {
+            (
+                [0.0, width  as f64],
+                [0.0, height as f64],
+                vec![
+                    Line::new(0.0, 0.0, width as f64, height as f64, Color::Red),
+                    Line::new(width as f64, 0.0, 0.0, height as f64, Color::Red),
+                ]
+            )
+        };
+    Canvas::default().x_bounds(x_bounds).y_bounds(y_bounds).paint(|ctx|{
+        for line in lines.iter() {
+            ctx.draw(line)
+        }
+    }).render(area, &mut to.buffer);
+    Ok(())
+}));

src/sampler/sampler_tui.rs

@@ -0,0 +1,155 @@
+use crate::*;
+use KeyCode::Char;
+
+pub struct SamplerTui {
+    pub state:   Sampler,
+    pub cursor:  (usize, usize),
+    pub editing: Option<Arc<RwLock<Sample>>>,
+    pub mode:    Option<SamplerMode>,
+    /// Size of actual notes area
+    pub size:    Measure<Tui>,
+    /// Lowest note displayed
+    pub note_lo: AtomicUsize,
+    pub note_pt: AtomicUsize,
+    color:       ItemPalette
+}
+
+impl SamplerTui {
+    /// Immutable reference to sample at cursor.
+    pub fn sample (&self) -> Option<&Arc<RwLock<Sample>>> {
+        for (i, sample) in self.state.mapped.iter().enumerate() {
+            if i == self.cursor.0 {
+                return sample.as_ref()
+            }
+        }
+        for (i, sample) in self.state.unmapped.iter().enumerate() {
+            if i + self.state.mapped.len() == self.cursor.0 {
+                return Some(sample)
+            }
+        }
+        None
+    }
+}
+
+from_jack!(|jack|SamplerTui{
+    Self {
+        cursor:  (0, 0),
+        editing: None,
+        mode:    None,
+        size:    Measure::new(),
+        note_lo: 36.into(),
+        note_pt: 36.into(),
+        color:   ItemPalette::from(Color::Rgb(64, 128, 32)),
+        state:   Sampler::new(jack, "sampler")?,
+    }
+});
+
+render!(<Tui>|self: SamplerTui|{
+    let keys_width  = 5;
+    let keys        = move||"";//SamplerKeys(self);
+    let fg          = self.color.base.rgb;
+    let bg          = self.color.darkest.rgb;
+    let border      = Fill::wh(Outer(Style::default().fg(fg).bg(bg)));
+    let with_border = |x|lay!([border, Fill::wh(&x)]);
+    let with_size   = |x|lay!([self.size, x]);
+    Tui::bg(bg, Fill::wh(with_border(Bsp::s(
+        Tui::fg(self.color.light.rgb, Tui::bold(true, "Sampler")),
+        with_size(Tui::shrink_y(1, Bsp::e(
+            Fixed::w(keys_width, keys()),
+            Fill::wh(render(|to: &mut TuiOutput|Ok({
+                let x           = to.area.x();
+                let bg_base     = self.color.darkest.rgb;
+                let bg_selected = self.color.darker.rgb;
+                let style_empty = Style::default().fg(self.color.base.rgb);
+                let style_full  = Style::default().fg(self.color.lighter.rgb);
+                let note_hi     = self.note_hi();
+                let note_pt     = self.note_point();
+                for y in 0..self.size.h() {
+                    let note  = note_hi - y as usize;
+                    let bg    = if note == note_pt { bg_selected } else { bg_base };
+                    let style = Some(style_empty.bg(bg));
+                    to.blit(&" (no sample) ", x, to.area.y() + y as u16, style)
+                }
+            })))
+        ))),
+    ))))
+});
+
+impl NoteRange for SamplerTui {
+    fn note_lo (&self) -> &AtomicUsize { &self.note_lo }
+    fn note_axis (&self) -> &AtomicUsize { &self.size.y  }
+}
+
+impl NotePoint for SamplerTui {
+    fn note_len (&self) -> usize {0/*TODO*/}
+    fn set_note_len (&self, x: usize) {}
+    fn note_point (&self) -> usize { self.note_pt.load(Relaxed) }
+    fn set_note_point (&self, x: usize) { self.note_pt.store(x, Relaxed); }
+}
+
+pub enum SamplerMode {
+    // Load sample from path
+    Import(usize, FileBrowser),
+}
+
+handle!(<Tui>|self: SamplerTui, input|SamplerTuiCommand::execute_with_state(self, input));
+
+pub enum SamplerTuiCommand {
+    Import(FileBrowserCommand),
+    SelectNote(usize),
+    SelectField(usize),
+    Sample(SamplerCommand),
+}
+
+input_to_command!(SamplerTuiCommand: <Tui>|state: SamplerTui, input|match state.mode {
+    Some(SamplerMode::Import(..)) => Self::Import(
+        FileBrowserCommand::input_to_command(state, input)?
+    ),
+    _ => match input.event() {
+        // load sample
+        key_pat!(Shift-Char('L')) => {
+            Self::Import(FileBrowserCommand::Begin)
+        },
+        key_pat!(KeyCode::Up) => {
+            Self::SelectNote(state.note_point().overflowing_add(1).0.min(127))
+        },
+        key_pat!(KeyCode::Down) => {
+            Self::SelectNote(state.note_point().overflowing_sub(1).0.min(127))
+        },
+        _ => return None
+    }
+        //key_pat!(KeyCode::Char('p')) => if let Some(sample) = self.sample() {
+            //voices.write().unwrap().push(Sample::play(sample, 0, &100.into()));
+        //},
+        //key_pat!(KeyCode::Char('a')) => {
+            //let sample = Arc::new(RwLock::new(Sample::new("", 0, 0, vec![])));
+            //self.mode = None;//Some(Exit::boxed(AddSampleModal::new(&sample, &voices)?));
+            //unmapped.push(sample);
+        //},
+        //key_pat!(KeyCode::Char('r')) => if let Some(sample) = self.sample() {
+            //self.mode = None;//Some(Exit::boxed(AddSampleModal::new(&sample, &voices)?));
+        //},
+        //key_pat!(KeyCode::Enter) => if let Some(sample) = self.sample() {
+            //self.editing = Some(sample.clone());
+        //},
+        //_ => {
+            //return Ok(None)
+        //}
+    //}
+});
+
+command!(|self: SamplerTuiCommand, state: SamplerTui|match self {
+    Self::Import(FileBrowserCommand::Begin) => {
+        let voices = &state.state.voices;
+        let sample = Arc::new(RwLock::new(Sample::new("", 0, 0, vec![])));
+        state.mode = Some(SamplerMode::Import(0, FileBrowser::new(None)?));
+        None
+    },
+    Self::SelectNote(index) => {
+        let old = state.note_point();
+        state.set_note_point(index);
+        Some(Self::SelectNote(old))
+    },
+    Self::Sample(cmd) => cmd.execute(&mut state.state)?.map(Self::Sample),
+    _ => todo!()
+});

src/sampler/voice.rs

@@ -0,0 +1,30 @@
+use crate::*;
+
+/// A currently playing instance of a sample.
+#[derive(Default, Debug, Clone)]
+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 -= 1;
+            return Some([0.0, 0.0])
+        }
+        let sample = self.sample.read().unwrap();
+        if self.position < sample.end {
+            let position = self.position;
+            self.position += 1;
+            return sample.channels[0].get(position).map(|_amplitude|[
+                sample.channels[0][position] * self.velocity * sample.gain,
+                sample.channels[0][position] * self.velocity * sample.gain,
+            ])
+        }
+        None
+    }
+}