mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 19:56:42 +01:00
569 lines
19 KiB
Rust
569 lines
19 KiB
Rust
//! Sampler (currently 16bit WAVs at system rate; TODO convert/resample)
|
|
|
|
use crate::{core::*, view::*, model::MODAL};
|
|
|
|
use symphonia::core::codecs::{DecoderOptions, CODEC_TYPE_NULL};
|
|
use symphonia::core::errors::Error;
|
|
use symphonia::core::formats::FormatOptions;
|
|
use symphonia::core::io::MediaSourceStream;
|
|
use symphonia::core::meta::MetadataOptions;
|
|
use symphonia::core::probe::Hint;
|
|
|
|
/// 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: Vec<Voice>,
|
|
pub ports: JackPorts,
|
|
pub buffer: Vec<Vec<f32>>,
|
|
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.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, "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, "cursor_down", "move cursor down", |state: &mut Sampler| {
|
|
state.cursor.0 = (state.cursor.0 + 1) % (state.mapped.len() + state.unmapped.len());
|
|
Ok(true)
|
|
}],
|
|
[Char('t'), NONE, "sample_play", "play current sample", |state: &mut Sampler| {
|
|
if let Some(sample) = state.sample() {
|
|
state.voices.push(Sample::play(sample, 0, &100.into()))
|
|
}
|
|
Ok(true)
|
|
}],
|
|
[Char('a'), NONE, "sample_add", "add a new sample", |state: &mut Sampler| {
|
|
let sample = Sample::new("", 0, 0, vec![]);
|
|
*MODAL.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample)?));
|
|
state.unmapped.push(sample);
|
|
Ok(true)
|
|
}],
|
|
[Char('r'), NONE, "sample_replace", "replace selected sample", |state: &mut Sampler| {
|
|
if let Some(sample) = state.sample() {
|
|
*MODAL.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample)?));
|
|
}
|
|
Ok(true)
|
|
}],
|
|
[Enter, NONE, "sample_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: vec![],
|
|
ports,
|
|
buffer: vec![vec![0.0;16384];2],
|
|
output_gain: 0.5,
|
|
}))
|
|
}
|
|
|
|
/// 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.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.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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 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))
|
|
}
|
|
|
|
/// A sound sample.
|
|
pub struct Sample {
|
|
pub name: String,
|
|
pub start: usize,
|
|
pub end: usize,
|
|
pub channels: Vec<Vec<f32>>,
|
|
}
|
|
|
|
impl Sample {
|
|
pub fn new (
|
|
name: &str, start: usize, end: usize, channels: Vec<Vec<f32>>
|
|
) -> Arc<RwLock<Self>> {
|
|
Arc::new(RwLock::new(Self { name: name.to_string(), start, end, channels }))
|
|
}
|
|
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.
|
|
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 Some([
|
|
sample.channels[0][position] * self.velocity,
|
|
sample.channels[0][position] * self.velocity,
|
|
])
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
pub struct AddSampleModal {
|
|
exited: bool,
|
|
dir: PathBuf,
|
|
subdirs: Vec<OsString>,
|
|
files: Vec<OsString>,
|
|
cursor: usize,
|
|
offset: usize,
|
|
sample: Arc<RwLock<Sample>>,
|
|
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 {
|
|
fn new (sample: &Arc<RwLock<Sample>>) -> 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(),
|
|
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() {
|
|
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))
|
|
}
|
|
|
|
fn load_sample () {
|
|
// Get the first command line argument.
|
|
let args: Vec<String> = std::env::args().collect();
|
|
let path = args.get(1).expect("file path not provided");
|
|
|
|
// Open the media source.
|
|
let src = std::fs::File::open(path).expect("failed to open media");
|
|
|
|
// Create the media source stream.
|
|
let mss = MediaSourceStream::new(Box::new(src), Default::default());
|
|
|
|
// Create a probe hint using the file's extension. [Optional]
|
|
let mut hint = Hint::new();
|
|
hint.with_extension("mp3");
|
|
|
|
// Use the default options for metadata and format readers.
|
|
let meta_opts: MetadataOptions = Default::default();
|
|
let fmt_opts: FormatOptions = Default::default();
|
|
|
|
// Probe the media source.
|
|
let probed = symphonia::default::get_probe()
|
|
.format(&hint, mss, &fmt_opts, &meta_opts)
|
|
.expect("unsupported format");
|
|
|
|
// Get the instantiated format reader.
|
|
let mut format = probed.format;
|
|
|
|
// Find the first audio track with a known (decodeable) codec.
|
|
let track = format
|
|
.tracks()
|
|
.iter()
|
|
.find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
|
|
.expect("no supported audio tracks");
|
|
|
|
// Use the default options for the decoder.
|
|
let dec_opts: DecoderOptions = Default::default();
|
|
|
|
// Create a decoder for the track.
|
|
let mut decoder = symphonia::default::get_codecs()
|
|
.make(&track.codec_params, &dec_opts)
|
|
.expect("unsupported codec");
|
|
|
|
// Store the track identifier, it will be used to filter packets.
|
|
let track_id = track.id;
|
|
|
|
// The decode loop.
|
|
loop {
|
|
// Get the next packet from the media format.
|
|
let packet = match format.next_packet() {
|
|
Ok(packet) => packet,
|
|
Err(Error::ResetRequired) => {
|
|
// The track list has been changed. Re-examine it and create a new set of decoders,
|
|
// then restart the decode loop. This is an advanced feature and it is not
|
|
// unreasonable to consider this "the end." As of v0.5.0, the only usage of this is
|
|
// for chained OGG physical streams.
|
|
unimplemented!();
|
|
}
|
|
Err(err) => {
|
|
// A unrecoverable error occurred, halt decoding.
|
|
panic!("{}", err);
|
|
}
|
|
};
|
|
|
|
// Consume any new metadata that has been read since the last packet.
|
|
while !format.metadata().is_latest() {
|
|
// Pop the old head of the metadata queue.
|
|
format.metadata().pop();
|
|
|
|
// Consume the new metadata at the head of the metadata queue.
|
|
}
|
|
|
|
// If the packet does not belong to the selected track, skip over it.
|
|
if packet.track_id() != track_id {
|
|
continue;
|
|
}
|
|
|
|
// Decode the packet into audio samples.
|
|
match decoder.decode(&packet) {
|
|
Ok(_decoded) => {
|
|
// Consume the decoded audio samples (see below).
|
|
}
|
|
Err(Error::IoError(_)) => {
|
|
// The packet failed to decode due to an IO error, skip the packet.
|
|
continue;
|
|
}
|
|
Err(Error::DecodeError(_)) => {
|
|
// The packet failed to decode due to invalid data, skip the packet.
|
|
continue;
|
|
}
|
|
Err(err) => {
|
|
// An unrecoverable error occurred, halt decoding.
|
|
panic!("{}", err);
|
|
}
|
|
}
|
|
}
|
|
}
|