mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 19:56:42 +01:00
617 lines
21 KiB
Rust
617 lines
21 KiB
Rust
use crate::*;
|
|
|
|
/// The sampler plugin plays sounds.
|
|
pub struct Sampler<E: Engine> {
|
|
_engine: PhantomData<E>,
|
|
pub jack: Arc<RwLock<JackClient>>,
|
|
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
|
|
}
|
|
|
|
impl<E: Engine> Sampler<E> {
|
|
pub fn from_edn <'e> (args: &[Edn<'e>]) -> Usually<JackDevice<Tui>> {
|
|
let mut name = String::new();
|
|
let mut dir = String::new();
|
|
let mut samples = BTreeMap::new();
|
|
edn!(edn in args {
|
|
Edn::Map(map) => {
|
|
if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
|
|
name = String::from(*n);
|
|
}
|
|
if let Some(Edn::Str(n)) = map.get(&Edn::Key(":dir")) {
|
|
dir = String::from(*n);
|
|
}
|
|
},
|
|
Edn::List(args) => match args.get(0) {
|
|
Some(Edn::Symbol("sample")) => {
|
|
let (midi, sample) = Sample::from_edn(&dir, &args[1..])?;
|
|
if let Some(midi) = midi {
|
|
samples.insert(midi, sample);
|
|
} else {
|
|
panic!("sample without midi binding: {}", sample.read().unwrap().name);
|
|
}
|
|
},
|
|
_ => panic!("unexpected in sampler {name}: {args:?}")
|
|
},
|
|
_ => panic!("unexpected in sampler {name}: {edn:?}")
|
|
});
|
|
Self::new(&name, Some(samples))
|
|
}
|
|
|
|
pub fn new (
|
|
name: &str, mapped: Option<BTreeMap<u7, Arc<RwLock<Sample>>>>
|
|
) -> Usually<JackDevice<Tui>> {
|
|
Jack::new(name)?
|
|
.midi_in("midi")
|
|
.audio_in("recL")
|
|
.audio_in("recR")
|
|
.audio_out("outL")
|
|
.audio_out("outR")
|
|
.run(|ports|Box::new(Self {
|
|
_engine: Default::default(),
|
|
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
|
|
}
|
|
|
|
/// 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<E: Engine> Audio for Sampler<E> {
|
|
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
|
|
}
|
|
}
|
|
impl Handle<Tui> for Sampler<Tui> {
|
|
fn handle (&mut self, from: &TuiInput) -> Perhaps<bool> {
|
|
match from.event() {
|
|
key!(KeyCode::Up) => {
|
|
self.cursor.0 = if self.cursor.0 == 0 {
|
|
self.mapped.len() + self.unmapped.len() - 1
|
|
} else {
|
|
self.cursor.0 - 1
|
|
};
|
|
Ok(Some(true))
|
|
},
|
|
key!(KeyCode::Down) => {
|
|
self.cursor.0 = (self.cursor.0 + 1) % (self.mapped.len() + self.unmapped.len());
|
|
Ok(Some(true))
|
|
},
|
|
key!(KeyCode::Char('p')) => {
|
|
if let Some(sample) = self.sample() {
|
|
self.voices.write().unwrap().push(Sample::play(sample, 0, &100.into()));
|
|
}
|
|
Ok(Some(true))
|
|
},
|
|
key!(KeyCode::Char('a')) => {
|
|
let sample = Arc::new(RwLock::new(Sample::new("", 0, 0, vec![])));
|
|
*self.modal.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample, &self.voices)?));
|
|
self.unmapped.push(sample);
|
|
Ok(Some(true))
|
|
},
|
|
key!(KeyCode::Char('r')) => {
|
|
if let Some(sample) = self.sample() {
|
|
*self.modal.lock().unwrap() = Some(Exit::boxed(AddSampleModal::new(&sample, &self.voices)?));
|
|
}
|
|
Ok(Some(true))
|
|
},
|
|
key!(KeyCode::Enter) => {
|
|
if let Some(sample) = self.sample() {
|
|
self.editing = Some(sample.clone());
|
|
}
|
|
Ok(Some(true))
|
|
}
|
|
_ => Ok(None)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Widget for Sampler<Tui> {
|
|
type Engine = Tui;
|
|
fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
|
|
todo!()
|
|
}
|
|
fn render (&self, to: &mut TuiOutput) -> Usually<()> {
|
|
tui_render_sampler(self, to)
|
|
}
|
|
}
|
|
|
|
pub fn tui_render_sampler (sampler: &Sampler<Tui>, to: &mut TuiOutput) -> Usually<()> {
|
|
let [x, y, _, height] = to.area();
|
|
let style = Style::default().gray();
|
|
let title = format!(" {} ({})", sampler.name, sampler.voices.read().unwrap().len());
|
|
to.blit(&title, 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 sampler.mapped.iter()
|
|
.map(|(note, sample)|(Some(note), sample))
|
|
.chain(sampler.unmapped.iter().map(|sample|(None, sample)))
|
|
{
|
|
if y1 >= height {
|
|
break
|
|
}
|
|
let active = j == sampler.cursor.0;
|
|
width = width.max(
|
|
draw_sample(to, x, y + y1, note, &*sample.read().unwrap(), active)?
|
|
);
|
|
y1 = y1 + 1;
|
|
j = j + 1;
|
|
}
|
|
let height = ((2 + y1) as u16).min(height);
|
|
//Ok(Some([x, y, (width as u16).min(to.area().w()), height]))
|
|
Ok(())
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
/// 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 from_edn <'e> (dir: &str, args: &[Edn<'e>]) -> Usually<(Option<u7>, Arc<RwLock<Self>>)> {
|
|
let mut name = String::new();
|
|
let mut file = String::new();
|
|
let mut midi = None;
|
|
let mut start = 0usize;
|
|
edn!(edn in args {
|
|
Edn::Map(map) => {
|
|
if let Some(Edn::Str(n)) = map.get(&Edn::Key(":name")) {
|
|
name = String::from(*n);
|
|
}
|
|
if let Some(Edn::Str(f)) = map.get(&Edn::Key(":file")) {
|
|
file = String::from(*f);
|
|
}
|
|
if let Some(Edn::Int(i)) = map.get(&Edn::Key(":start")) {
|
|
start = *i as usize;
|
|
}
|
|
if let Some(Edn::Int(m)) = map.get(&Edn::Key(":midi")) {
|
|
midi = Some(u7::from(*m as u8));
|
|
}
|
|
},
|
|
_ => panic!("unexpected in sample {name}"),
|
|
});
|
|
let (end, data) = read_sample_data(&format!("{dir}/{file}"))?;
|
|
Ok((midi, Arc::new(RwLock::new(Self::new(&name, start, end, data)))))
|
|
}
|
|
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))
|
|
}
|
|
|
|
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>,
|
|
}
|
|
|
|
impl Exit for AddSampleModal {
|
|
fn exited (&self) -> bool {
|
|
self.exited
|
|
}
|
|
fn exit (&mut self) {
|
|
self.exited = true
|
|
}
|
|
}
|
|
|
|
impl Widget for AddSampleModal {
|
|
type Engine = Tui;
|
|
fn layout (&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))
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|