//! Writes a take as ready-to-use files: the full loop, one file per slice and a wavetable. use crate::settings::Settings; use crate::take::{render, wavetable, Take, TABLE}; use common_dsp::{note_name, wav}; use std::path::{Path, PathBuf}; #[derive(Debug, Clone, PartialEq)] pub struct Exported { pub folder: PathBuf, pub files: usize, /// Why no wavetable was written although one was requested. pub wavetable_skipped: Option<&'static str>, } /// UTC date and time for folder names, from the Unix time in seconds. pub fn stamp(unix: u64) -> String { let days = (unix / 86400) as i64; let secs = unix % 86400; // Civil-from-days (H. Hinnant), proleptic Gregorian calendar. let z = days + 719468; let era = z.div_euclid(146097); let doe = z - era * 146097; let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); let mp = (5 * doy + 2) / 153; let day = doy - (153 * mp + 2) / 5 + 1; let month = if mp < 10 { mp + 3 } else { mp - 9 }; let year = yoe + era * 400 + i64::from(month <= 2); format!( "{year:04}-{month:02}-{day:02}_{:02}{:02}{:02}", secs / 3600, secs / 60 % 60, secs % 60 ) } /// Writes a captured take's loop to `root/takes/` right away, so it survives a reload or a /// crash. Never overwrites: a name already taken gets a counter. Returns the file written. pub fn save_take(take: &Take, root: &Path, unix: u64) -> std::io::Result { let folder = root.join("takes"); std::fs::create_dir_all(&folder)?; let base = format!( "{}_{:.0}bpm_{}bar{}", stamp(unix), take.tempo(), take.bars, if take.bars == 1 { "" } else { "s" } ); let wave = wav::Wave { channels: 2, rate: take.rate.round() as u32, samples: take.audio.clone(), root: None, frame: None, }; let bytes = wav::encode(&wave); for n in 1..1000 { let name = if n == 1 { format!("{base}.wav") } else { format!("{base}_{n}.wav") }; let path = folder.join(name); match std::fs::OpenOptions::new() .write(true) .create_new(true) .open(&path) { Ok(mut file) => { std::io::Write::write_all(&mut file, &bytes)?; return Ok(path); } Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue, Err(e) => return Err(e), } } Err(std::io::Error::new( std::io::ErrorKind::AlreadyExists, "too many takes with the same name", )) } pub fn export( take: &Take, settings: &Settings, selected: Option, root: &Path, unix: u64, ) -> std::io::Result { let folder = root.join(format!("{}_{:.0}bpm", stamp(unix), take.tempo())); std::fs::create_dir_all(&folder)?; let rate = take.rate.round() as u32; let stereo = |samples: Vec, root: Option| wav::Wave { channels: 2, rate, samples, root, frame: None, }; wav::write(&folder.join("loop.wav"), &stereo(take.audio.clone(), None))?; let mut files = 1; for (i, s) in take.slices.iter().enumerate().filter(|(_, s)| s.enabled) { let name = match s.root { Some(n) => format!("s{:02}_{}.wav", i + 1, note_name(n)), None => format!("s{:02}.wav", i + 1), }; wav::write( &folder.join(name), &stereo(render(take, s, settings), s.root), )?; files += 1; } let mut wavetable_skipped = None; if settings.wavetable { let source = selected .and_then(|i| take.slices.get(i)) .or_else(|| take.slices.iter().find(|s| s.enabled && s.root.is_some())); match source.map(|s| wavetable(&take.mono(s.start, s.end), take.rate)) { Some(Some(table)) => { let w = wav::Wave { channels: 1, rate, samples: table, root: None, frame: Some(TABLE as u32), }; wav::write(&folder.join("wavetable.wav"), &w)?; files += 1; } Some(None) => wavetable_skipped = Some("the slice has no clear pitch"), None => wavetable_skipped = Some("no slice selected"), } } Ok(Exported { folder, files, wavetable_skipped, }) }