wip: refactor into fewer crates

crates/sampler/src/sampler_model.rs

@@ -1,191 +0,0 @@
-use crate::*;
-
-pub type MaybeSample = Option<Arc<RwLock<Sample>>>;
-
-/// The sampler device plays sounds in response to MIDI notes.
-#[derive(Debug)]
-pub struct Sampler {
-    pub name:        String,
-    pub mapped:      [MaybeSample;128],
-    pub recording:   Option<(usize, Arc<RwLock<Sample>>)>,
-    pub unmapped:    Vec<Arc<RwLock<Sample>>>,
-    pub voices:      Arc<RwLock<Vec<Voice>>>,
-    pub midi_in:     Option<JackMidiIn>,
-    pub audio_ins:   Vec<JackAudioIn>,
-    pub input_meter: Vec<f32>,
-    pub audio_outs:  Vec<JackAudioOut>,
-    pub buffer:      Vec<Vec<f32>>,
-    pub output_gain: f32,
-    pub editing: MaybeSample,
-    pub mode:    Option<SamplerMode>,
-    /// Size of actual notes area
-    pub size:    Measure<TuiOut>,
-    /// Lowest note displayed
-    pub note_lo: AtomicUsize,
-    /// Selected note
-    pub note_pt: AtomicUsize,
-    /// Selected note as row/col
-    pub cursor:  (AtomicUsize, AtomicUsize),
-    pub color:   ItemTheme
-}
-
-impl Default for Sampler {
-    fn default () -> Self {
-        Self {
-            midi_in:     None,
-            audio_ins:   vec![],
-            input_meter: vec![0.0;2],
-            audio_outs:  vec![],
-            name:        "tek_sampler".to_string(),
-            mapped:      [const { None };128],
-            unmapped:    vec![],
-            voices:      Arc::new(RwLock::new(vec![])),
-            buffer:      vec![vec![0.0;16384];2],
-            output_gain: 1.,
-            recording:   None,
-            mode:        None,
-            editing:     None,
-            size:        Default::default(),
-            note_lo:     0.into(),
-            note_pt:     0.into(),
-            cursor:      (0.into(), 0.into()),
-            color:       Default::default(),
-        }
-    }
-}
-
-impl Sampler {
-    pub fn new (
-        jack:       &Jack,
-        name:       impl AsRef<str>,
-        midi_from:  &[PortConnect],
-        audio_from: &[&[PortConnect];2],
-        audio_to:   &[&[PortConnect];2],
-    ) -> Usually<Self> {
-        let name = name.as_ref();
-        Ok(Self {
-            midi_in: Some(JackMidiIn::new(jack, format!("M/{name}"), midi_from)?),
-            audio_ins: vec![
-                JackAudioIn::new(jack, &format!("L/{name}"), audio_from[0])?,
-                JackAudioIn::new(jack, &format!("R/{name}"), audio_from[1])?,
-            ],
-            audio_outs: vec![
-                JackAudioOut::new(jack, &format!("{name}/L"), audio_to[0])?,
-                JackAudioOut::new(jack, &format!("{name}/R"), audio_to[1])?,
-            ],
-            ..Default::default()
-        })
-    }
-    pub fn cancel_recording (&mut self) {
-        self.recording = None;
-    }
-    pub fn begin_recording (&mut self, index: usize) {
-        self.recording = Some((
-            index,
-            Arc::new(RwLock::new(Sample::new("Sample", 0, 0, vec![vec![];self.audio_ins.len()])))
-        ));
-    }
-    pub fn finish_recording (&mut self) -> MaybeSample {
-        let recording = self.recording.take();
-        if let Some((index, sample)) = recording {
-            let old = self.mapped[index].clone();
-            self.mapped[index] = Some(sample);
-            old
-        } else {
-            None
-        }
-    }
-    /// Immutable reference to sample at cursor.
-    pub fn sample (&self) -> Option<&Arc<RwLock<Sample>>> {
-        for (i, sample) in self.mapped.iter().enumerate() {
-            if i == self.cursor().0 {
-                return sample.as_ref()
-            }
-        }
-        for (i, sample) in self.unmapped.iter().enumerate() {
-            if i + self.mapped.len() == self.cursor().0 {
-                return Some(sample)
-            }
-        }
-        None
-    }
-    /// Value of cursor
-    pub fn cursor (&self) -> (usize, usize) {
-        (self.cursor.0.load(Relaxed), self.cursor.1.load(Relaxed))
-    }
-    /// Assign sample to pitch
-    pub fn set_sample (&mut self, pitch: u7, sample: MaybeSample) -> MaybeSample {
-        let i = pitch.as_int() as usize;
-        let old = self.mapped[i].clone();
-        self.mapped[i] = sample;
-        old
-    }
-}
-
-impl NoteRange for Sampler {
-    fn note_lo (&self) -> &AtomicUsize {
-        &self.note_lo
-    }
-    fn note_axis (&self) -> &AtomicUsize {
-        &self.size.y
-    }
-}
-
-impl NotePoint for Sampler {
-    fn note_len (&self) -> usize {
-        0 /*TODO?*/
-    }
-    fn set_note_len (&self, x: usize) -> usize {
-        0 /*TODO?*/
-    }
-    fn note_pos (&self) -> usize {
-        self.note_pt.load(Relaxed)
-    }
-    fn set_note_pos (&self, x: usize) -> usize {
-        let old = self.note_pt.swap(x, Relaxed);
-        self.cursor.0.store(x % 8, Relaxed);
-        self.cursor.1.store(x / 8, Relaxed);
-        old
-    }
-}
-
-/// A sound sample.
-#[derive(Default, Debug)]
-pub struct Sample {
-    pub name:     Arc<str>,
-    pub start:    usize,
-    pub end:      usize,
-    pub channels: Vec<Vec<f32>>,
-    pub rate:     Option<usize>,
-    pub gain:     f32,
-}
-
-impl Sample {
-    pub fn new (name: impl AsRef<str>, start: usize, end: usize, channels: Vec<Vec<f32>>) -> Self {
-        Self { name: name.as_ref().into(), 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,
-        }
-    }
-}
-
-/// 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,
-}
-
-#[derive(Debug)]
-pub enum SamplerMode {
-    // Load sample from path
-    Import(usize, FileBrowser),
-}
-