From 05b62bb1c0d8906aa454070872bd3495c6a42f9c Mon Sep 17 00:00:00 2001 From: mitchmindtree Date: Mon, 13 Jan 2020 15:27:41 +0100 Subject: [PATCH] Remove `UnknownTypeBuffer` in favour of specifying sample type. This is an implementation of the planned changes described in #119. For a quick overview of how the API has changed, check out the updated examples. **TODO:** - [x] Update API. - [x] Update examples. - [ ] Remove `data_type` field from `Format` (see [here](https://github.com/RustAudio/cpal/issues/119#issuecomment-573788380)). - Update backends: - [x] null - [x] ALSA - [ ] ASIO - [ ] WASAPI - [ ] CoreAudio - [ ] Emscripten Closes #119 Closes #260 --- examples/beep.rs | 73 +++--- examples/feedback.rs | 80 +++---- examples/record_wav.rs | 85 +++---- src/host/alsa/mod.rs | 510 ++++++++++++++++++++++++++--------------- src/host/null/mod.rs | 49 ++-- src/lib.rs | 85 ++----- src/platform/mod.rs | 26 ++- src/samples_formats.rs | 27 +-- src/traits.rs | 28 ++- 9 files changed, 543 insertions(+), 420 deletions(-) diff --git a/examples/beep.rs b/examples/beep.rs index 671f1bf..d143fff 100644 --- a/examples/beep.rs +++ b/examples/beep.rs @@ -1,56 +1,61 @@ extern crate anyhow; extern crate cpal; -use cpal::traits::{DeviceTrait, StreamTrait, HostTrait}; +use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; fn main() -> Result<(), anyhow::Error> { let host = cpal::default_host(); - let device = host.default_output_device().expect("failed to find a default output device"); + let device = host + .default_output_device() + .expect("failed to find a default output device"); let format = device.default_output_format()?; let sample_rate = format.sample_rate.0 as f32; - let channels = format.channels; - let mut sample_clock = 0f32; + let channels = format.channels as usize; // Produce a sinusoid of maximum amplitude. + let mut sample_clock = 0f32; let mut next_value = move || { sample_clock = (sample_clock + 1.0) % sample_rate; (sample_clock * 440.0 * 2.0 * 3.141592 / sample_rate).sin() }; - let stream = device.build_output_stream(&format, move |data| { - match data { - cpal::StreamData::Output { buffer: cpal::UnknownTypeOutputBuffer::U16(mut buffer) } => { - for sample in buffer.chunks_mut(channels as usize) { - let value = ((next_value() * 0.5 + 0.5) * std::u16::MAX as f32) as u16; - for out in sample.iter_mut() { - *out = value; - } - } - }, - cpal::StreamData::Output { buffer: cpal::UnknownTypeOutputBuffer::I16(mut buffer) } => { - for sample in buffer.chunks_mut(channels as usize) { - let value = (next_value() * std::i16::MAX as f32) as i16; - for out in sample.iter_mut() { - *out = value; - } - } - }, - cpal::StreamData::Output { buffer: cpal::UnknownTypeOutputBuffer::F32(mut buffer) } => { - for sample in buffer.chunks_mut(channels as usize) { - let value = next_value(); - for out in sample.iter_mut() { - *out = value; - } - } - }, - _ => (), - } - }, move |err| { + let err_fn = |err| { eprintln!("an error occurred on stream: {}", err); - })?; + }; + + let stream = match format.data_type { + cpal::SampleFormat::F32 => device.build_output_stream( + &format, + move |mut data| write_data::(&mut *data, channels, &mut next_value), + err_fn, + ), + cpal::SampleFormat::I16 => device.build_output_stream( + &format, + move |mut data| write_data::(&mut *data, channels, &mut next_value), + err_fn, + ), + cpal::SampleFormat::U16 => device.build_output_stream( + &format, + move |mut data| write_data::(&mut *data, channels, &mut next_value), + err_fn, + ), + }?; + stream.play()?; std::thread::sleep(std::time::Duration::from_millis(1000)); Ok(()) } + +fn write_data(output: &mut [T], channels: usize, next_sample: &mut dyn FnMut() -> f32) +where + T: cpal::Sample, +{ + for frame in output.chunks_mut(channels) { + let value: T = cpal::Sample::from::(&next_sample()); + for sample in frame.iter_mut() { + *sample = value; + } + } +} diff --git a/examples/feedback.rs b/examples/feedback.rs index e6875b2..6697718 100644 --- a/examples/feedback.rs +++ b/examples/feedback.rs @@ -49,50 +49,44 @@ fn main() -> Result<(), anyhow::Error> { // Build streams. println!("Attempting to build both streams with `{:?}`.", format); - let input_stream = input_device.build_input_stream(&format, move |data| { - match data { - cpal::StreamData::Input { - buffer: cpal::UnknownTypeInputBuffer::F32(buffer), - } => { - let mut output_fell_behind = false; - for &sample in buffer.iter() { - if producer.push(sample).is_err() { - output_fell_behind = true; - } + let input_stream = input_device.build_input_stream( + &format, + move |data| { + let mut output_fell_behind = false; + for &sample in data.iter() { + if producer.push(sample).is_err() { + output_fell_behind = true; } - if output_fell_behind { - eprintln!("output stream fell behind: try increasing latency"); - } - }, - _ => panic!("Expected input with f32 data"), - } - }, move |err| { - eprintln!("an error occurred on input stream: {}", err); - })?; - let output_stream = output_device.build_output_stream(&format, move |data| { - match data { - cpal::StreamData::Output { - buffer: cpal::UnknownTypeOutputBuffer::F32(mut buffer), - } => { - let mut input_fell_behind = None; - for sample in buffer.iter_mut() { - *sample = match consumer.pop() { - Ok(s) => s, - Err(err) => { - input_fell_behind = Some(err); - 0.0 - }, - }; - } - if let Some(err) = input_fell_behind { - eprintln!("input stream fell behind: {:?}: try increasing latency", err); - } - }, - _ => panic!("Expected output with f32 data"), - } - }, move |err| { - eprintln!("an error occurred on output stream: {}", err); - })?; + } + if output_fell_behind { + eprintln!("output stream fell behind: try increasing latency"); + } + }, + |err| { + eprintln!("an error occurred on stream: {}", err); + }, + )?; + let output_stream = output_device.build_output_stream( + &format, + move |mut data| { + let mut input_fell_behind = None; + for sample in data.iter_mut() { + *sample = match consumer.pop() { + Ok(s) => s, + Err(err) => { + input_fell_behind = Some(err); + 0.0 + }, + }; + } + if let Some(err) = input_fell_behind { + eprintln!("input stream fell behind: {:?}: try increasing latency", err); + } + }, + move |err| { + eprintln!("an error occurred on output stream: {}", err); + }, + )?; println!("Successfully built streams."); // Play the streams. diff --git a/examples/record_wav.rs b/examples/record_wav.rs index f69c8d0..36e0c86 100644 --- a/examples/record_wav.rs +++ b/examples/record_wav.rs @@ -7,6 +7,9 @@ extern crate cpal; extern crate hound; use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; +use std::sync::{Arc, Mutex}; +use std::fs::File; +use std::io::BufWriter; fn main() -> Result<(), anyhow::Error> { // Use the default host for working with audio devices. @@ -25,55 +28,36 @@ fn main() -> Result<(), anyhow::Error> { const PATH: &'static str = concat!(env!("CARGO_MANIFEST_DIR"), "/recorded.wav"); let spec = wav_spec_from_format(&format); let writer = hound::WavWriter::create(PATH, spec)?; - let writer = std::sync::Arc::new(std::sync::Mutex::new(Some(writer))); + let writer = Arc::new(Mutex::new(Some(writer))); // A flag to indicate that recording is in progress. println!("Begin recording..."); // Run the input stream on a separate thread. let writer_2 = writer.clone(); - let stream = device.build_input_stream(&format, move |data| { - // Otherwise write to the wav writer. - match data { - cpal::StreamData::Input { - buffer: cpal::UnknownTypeInputBuffer::U16(buffer), - } => { - if let Ok(mut guard) = writer_2.try_lock() { - if let Some(writer) = guard.as_mut() { - for sample in buffer.iter() { - let sample = cpal::Sample::to_i16(sample); - writer.write_sample(sample).ok(); - } - } - } - }, - cpal::StreamData::Input { - buffer: cpal::UnknownTypeInputBuffer::I16(buffer), - } => { - if let Ok(mut guard) = writer_2.try_lock() { - if let Some(writer) = guard.as_mut() { - for &sample in buffer.iter() { - writer.write_sample(sample).ok(); - } - } - } - }, - cpal::StreamData::Input { - buffer: cpal::UnknownTypeInputBuffer::F32(buffer), - } => { - if let Ok(mut guard) = writer_2.try_lock() { - if let Some(writer) = guard.as_mut() { - for &sample in buffer.iter() { - writer.write_sample(sample).ok(); - } - } - } - }, - _ => (), - } - }, move |err| { + + let err_fn = move |err| { eprintln!("an error occurred on stream: {}", err); - })?; + }; + + let stream = match format.data_type { + cpal::SampleFormat::F32 => device.build_input_stream( + &format, + move |mut data| write_input_data::(&*data, &writer_2), + err_fn, + ), + cpal::SampleFormat::I16 => device.build_input_stream( + &format, + move |mut data| write_input_data::(&*data, &writer_2), + err_fn, + ), + cpal::SampleFormat::U16 => device.build_input_stream( + &format, + move |mut data| write_input_data::(&*data, &writer_2), + err_fn, + ), + }?; + stream.play()?; // Let recording go for roughly three seconds. @@ -100,3 +84,20 @@ fn wav_spec_from_format(format: &cpal::Format) -> hound::WavSpec { sample_format: sample_format(format.data_type), } } + +type WavWriterHandle = Arc>>>>; + +fn write_input_data(input: &[T], writer: &WavWriterHandle) +where + T: cpal::Sample, + U: cpal::Sample + hound::Sample, +{ + if let Ok(mut guard) = writer.try_lock() { + if let Some(writer) = guard.as_mut() { + for &sample in input.iter() { + let sample: U = cpal::Sample::from(&sample); + writer.write_sample(sample).ok(); + } + } + } +} diff --git a/src/host/alsa/mod.rs b/src/host/alsa/mod.rs index 7068f26..f1724aa 100644 --- a/src/host/alsa/mod.rs +++ b/src/host/alsa/mod.rs @@ -1,29 +1,30 @@ extern crate alsa_sys as alsa; extern crate libc; -use std::{cmp, ffi, io, mem, ptr}; +use crate::{ + BackendSpecificError, + BuildStreamError, + ChannelCount, + DefaultFormatError, + DeviceNameError, + DevicesError, + Format, + InputData, + OutputData, + PauseStreamError, + PlayStreamError, + Sample, + SampleFormat, + SampleRate, + StreamError, + SupportedFormat, + SupportedFormatsError, +}; +use std::{cmp, ffi, io, ptr}; use std::sync::Arc; use std::thread::{self, JoinHandle}; use std::vec::IntoIter as VecIntoIter; - -use BackendSpecificError; -use BuildStreamError; -use ChannelCount; -use DefaultFormatError; -use DeviceNameError; -use DevicesError; -use Format; -use PauseStreamError; -use PlayStreamError; -use SampleFormat; -use SampleRate; -use StreamData; -use StreamError; -use SupportedFormat; -use SupportedFormatsError; use traits::{DeviceTrait, HostTrait, StreamTrait}; -use UnknownTypeInputBuffer; -use UnknownTypeOutputBuffer; pub use self::enumerate::{default_input_device, default_output_device, Devices}; @@ -89,12 +90,40 @@ impl DeviceTrait for Device { Device::default_output_format(self) } - fn build_input_stream(&self, format: &Format, data_callback: D, error_callback: E) -> Result where D: FnMut(StreamData) + Send + 'static, E: FnMut(StreamError) + Send + 'static { - Ok(Stream::new(Arc::new(self.build_stream_inner(format, alsa::SND_PCM_STREAM_CAPTURE)?), data_callback, error_callback)) + fn build_input_stream( + &self, + format: &Format, + data_callback: D, + error_callback: E, + ) -> Result + where + T: Sample, + D: FnMut(InputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static, + { + // TODO: Consider removing `data_type` field from `Format` and removing this. + assert_eq!(format.data_type, T::FORMAT, "sample format mismatch"); + let stream_inner = self.build_stream_inner(format, alsa::SND_PCM_STREAM_CAPTURE)?; + let stream = Stream::new_input(Arc::new(stream_inner), data_callback, error_callback); + Ok(stream) } - fn build_output_stream(&self, format: &Format, data_callback: D, error_callback: E) -> Result where D: FnMut(StreamData) + Send + 'static, E: FnMut(StreamError) + Send + 'static { - Ok(Stream::new(Arc::new(self.build_stream_inner(format, alsa::SND_PCM_STREAM_PLAYBACK)?), data_callback, error_callback)) + fn build_output_stream( + &self, + format: &Format, + data_callback: D, + error_callback: E, + ) -> Result + where + T: Sample, + D: FnMut(OutputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static, + { + // TODO: Consider removing `data_type` field from `Format` and removing this. + assert_eq!(format.data_type, T::FORMAT, "sample format mismatch"); + let stream_inner = self.build_stream_inner(format, alsa::SND_PCM_STREAM_PLAYBACK)?; + let stream = Stream::new_output(Arc::new(stream_inner), data_callback, error_callback); + Ok(stream) } } @@ -147,7 +176,11 @@ impl Drop for TriggerReceiver { pub struct Device(String); impl Device { - fn build_stream_inner(&self, format: &Format, stream_type: alsa::snd_pcm_stream_t) -> Result { + fn build_stream_inner( + &self, + format: &Format, + stream_type: alsa::snd_pcm_stream_t, + ) -> Result { let name = ffi::CString::new(self.0.clone()).expect("unable to clone device"); let handle = unsafe { @@ -510,6 +543,7 @@ unsafe impl Send for StreamInner {} unsafe impl Sync for StreamInner {} +#[derive(Debug, Eq, PartialEq)] enum StreamType { Input, Output } pub struct Stream { @@ -524,183 +558,291 @@ pub struct Stream { trigger: TriggerSender, } -/// The inner body of the audio processing thread. Takes the polymorphic -/// callback to avoid generating too much generic code. -fn stream_worker(rx: TriggerReceiver, - stream: &StreamInner, - data_callback: &mut (dyn FnMut(StreamData) + Send + 'static), - error_callback: &mut (dyn FnMut(StreamError) + Send + 'static)) { - let mut descriptors = Vec::new(); - let mut buffer = Vec::new(); - loop { - descriptors.clear(); - // Add the self-pipe for signaling termination. - descriptors.push(libc::pollfd { - fd: rx.0, - events: libc::POLLIN, - revents: 0, - }); +#[derive(Default)] +struct StreamWorkerContext { + descriptors: Vec, + buffer: Vec, +} - // Add ALSA polling fds. - descriptors.reserve(stream.num_descriptors); - let len = descriptors.len(); - let filled = unsafe { - alsa::snd_pcm_poll_descriptors( +fn input_stream_worker( + rx: TriggerReceiver, + stream: &StreamInner, + data_callback: &mut (dyn FnMut(InputData) + Send + 'static), + error_callback: &mut (dyn FnMut(StreamError) + Send + 'static), +) where + T: Sample, +{ + let mut ctxt = StreamWorkerContext::default(); + loop { + match poll_descriptors_and_prepare_buffer(&rx, stream, &mut ctxt, error_callback) { + PollDescriptorsFlow::Continue => continue, + PollDescriptorsFlow::Return => return, + PollDescriptorsFlow::Ready { available_frames, stream_type } => { + assert_eq!( + stream_type, + StreamType::Input, + "expected input stream, but polling descriptors indicated output", + ); + process_input::( + stream, + &mut ctxt.buffer, + available_frames, + data_callback, + error_callback, + ); + } + } + } +} + +fn output_stream_worker( + rx: TriggerReceiver, + stream: &StreamInner, + data_callback: &mut (dyn FnMut(OutputData) + Send + 'static), + error_callback: &mut (dyn FnMut(StreamError) + Send + 'static), +) where + T: Sample, +{ + let mut ctxt = StreamWorkerContext::default(); + loop { + match poll_descriptors_and_prepare_buffer(&rx, stream, &mut ctxt, error_callback) { + PollDescriptorsFlow::Continue => continue, + PollDescriptorsFlow::Return => return, + PollDescriptorsFlow::Ready { available_frames, stream_type } => { + assert_eq!( + stream_type, + StreamType::Output, + "expected output stream, but polling descriptors indicated input", + ); + process_output::( + stream, + &mut ctxt.buffer, + available_frames, + data_callback, + error_callback, + ); + } + } + } +} + +enum PollDescriptorsFlow { + Continue, + Return, + Ready { + stream_type: StreamType, + available_frames: usize, + } +} + +// This block is shared between both input and output stream worker functions. +fn poll_descriptors_and_prepare_buffer( + rx: &TriggerReceiver, + stream: &StreamInner, + ctxt: &mut StreamWorkerContext, + error_callback: &mut (dyn FnMut(StreamError) + Send + 'static), +) -> PollDescriptorsFlow { + let StreamWorkerContext { + ref mut descriptors, + ref mut buffer, + } = *ctxt; + + descriptors.clear(); + + // Add the self-pipe for signaling termination. + descriptors.push(libc::pollfd { + fd: rx.0, + events: libc::POLLIN, + revents: 0, + }); + + // Add ALSA polling fds. + descriptors.reserve(stream.num_descriptors); + let len = descriptors.len(); + let filled = unsafe { + alsa::snd_pcm_poll_descriptors( + stream.channel, + descriptors[len..].as_mut_ptr(), + stream.num_descriptors as libc::c_uint, + ) + }; + debug_assert_eq!(filled, stream.num_descriptors as libc::c_int); + unsafe { + descriptors.set_len(len + stream.num_descriptors); + } + + let res = unsafe { + // Don't timeout, wait forever. + libc::poll(descriptors.as_mut_ptr(), descriptors.len() as libc::nfds_t, -1) + }; + if res < 0 { + let description = format!("`libc::poll()` failed: {}", io::Error::last_os_error()); + error_callback(BackendSpecificError { description }.into()); + return PollDescriptorsFlow::Continue; + } else if res == 0 { + let description = String::from("`libc::poll()` spuriously returned"); + error_callback(BackendSpecificError { description }.into()); + return PollDescriptorsFlow::Continue; + } + + if descriptors[0].revents != 0 { + // The stream has been requested to be destroyed. + rx.clear_pipe(); + return PollDescriptorsFlow::Return; + } + + let stream_type = match check_for_pollout_or_pollin(stream, descriptors[1..].as_mut_ptr()) { + Ok(Some(ty)) => ty, + Ok(None) => { + // Nothing to process, poll again + return PollDescriptorsFlow::Continue; + }, + Err(err) => { + error_callback(err.into()); + return PollDescriptorsFlow::Continue; + } + }; + // Get the number of available samples for reading/writing. + let available_samples = match get_available_samples(stream) { + Ok(n) => n, + Err(err) => { + let description = format!("Failed to query the number of available samples: {}", err); + error_callback(BackendSpecificError { description }.into()); + return PollDescriptorsFlow::Continue; + } + }; + + // Only go on if there is at least `stream.period_len` samples. + if available_samples < stream.period_len { + return PollDescriptorsFlow::Continue; + } + + // Prepare the data buffer. + let buffer_size = stream.sample_format.sample_size() * available_samples; + buffer.resize(buffer_size, 0u8); + let available_frames = available_samples / stream.num_channels as usize; + + PollDescriptorsFlow::Ready { + stream_type, + available_frames, + } +} + +// Read input data from ALSA and deliver it to the user. +fn process_input( + stream: &StreamInner, + buffer: &mut [u8], + available_frames: usize, + data_callback: &mut (dyn FnMut(InputData) + Send + 'static), + error_callback: &mut dyn FnMut(StreamError), +) where + T: Sample, +{ + let result = unsafe { + alsa::snd_pcm_readi( + stream.channel, + buffer.as_mut_ptr() as *mut _, + available_frames as alsa::snd_pcm_uframes_t, + ) + }; + if let Err(err) = check_errors(result as _) { + let description = format!("`snd_pcm_readi` failed: {}", err); + error_callback(BackendSpecificError { description }.into()); + return; + } + let buffer = unsafe { cast_input_buffer::(buffer) }; + let input_data = InputData { buffer }; + data_callback(input_data); +} + +// Request data from the user's function and write it via ALSA. +// +// Returns `true` +fn process_output( + stream: &StreamInner, + buffer: &mut [u8], + available_frames: usize, + data_callback: &mut (dyn FnMut(OutputData) + Send + 'static), + error_callback: &mut dyn FnMut(StreamError), +) where + T: Sample, +{ + { + // We're now sure that we're ready to write data. + let buffer = unsafe { cast_output_buffer::(buffer) }; + let output_data = OutputData { buffer }; + data_callback(output_data); + } + loop { + let result = unsafe { + alsa::snd_pcm_writei( stream.channel, - descriptors[len..].as_mut_ptr(), - stream.num_descriptors as libc::c_uint, + buffer.as_ptr() as *const _, + available_frames as alsa::snd_pcm_uframes_t, ) }; - debug_assert_eq!(filled, stream.num_descriptors as libc::c_int); - unsafe { - descriptors.set_len(len + stream.num_descriptors); - } - - let res = unsafe { - // Don't timeout, wait forever. - libc::poll(descriptors.as_mut_ptr(), descriptors.len() as libc::nfds_t, -1) - }; - if res < 0 { - let description = format!("`libc::poll()` failed: {}", io::Error::last_os_error()); + if result == -libc::EPIPE as i64 { + // buffer underrun + // TODO: Notify the user of this. + unsafe { alsa::snd_pcm_recover(stream.channel, result as i32, 0) }; + } else if let Err(err) = check_errors(result as _) { + let description = format!("`snd_pcm_writei` failed: {}", err); error_callback(BackendSpecificError { description }.into()); continue; - } else if res == 0 { - let description = String::from("`libc::poll()` spuriously returned"); + } else if result as usize != available_frames { + let description = format!( + "unexpected number of frames written: expected {}, \ + result {} (this should never happen)", + available_frames, + result, + ); error_callback(BackendSpecificError { description }.into()); continue; - } - - if descriptors[0].revents != 0 { - // The stream has been requested to be destroyed. - rx.clear_pipe(); - return; - } - - let stream_type = match check_for_pollout_or_pollin(stream, descriptors[1..].as_mut_ptr()) { - Ok(Some(ty)) => ty, - Ok(None) => { - // Nothing to process, poll again - continue; - }, - Err(err) => { - error_callback(err.into()); - continue; - } - }; - // Get the number of available samples for reading/writing. - let available_samples = match get_available_samples(stream) { - Ok(n) => n, - Err(err) => { - let description = format!("Failed to query the number of available samples: {}", err); - error_callback(BackendSpecificError { description }.into()); - continue; - } - }; - - // Only go on if there is at least `stream.period_len` samples. - if available_samples < stream.period_len { - continue; - } - - // Prepare the data buffer. - let buffer_size = stream.sample_format.sample_size() * available_samples; - buffer.resize(buffer_size, 0u8); - let available_frames = available_samples / stream.num_channels as usize; - - match stream_type { - StreamType::Input => { - let result = unsafe { - alsa::snd_pcm_readi( - stream.channel, - buffer.as_mut_ptr() as *mut _, - available_frames as alsa::snd_pcm_uframes_t, - ) - }; - if let Err(err) = check_errors(result as _) { - let description = format!("`snd_pcm_readi` failed: {}", err); - error_callback(BackendSpecificError { description }.into()); - continue; - } - - let input_buffer = match stream.sample_format { - SampleFormat::I16 => UnknownTypeInputBuffer::I16(::InputBuffer { - buffer: unsafe { cast_input_buffer(&mut buffer) }, - }), - SampleFormat::U16 => UnknownTypeInputBuffer::U16(::InputBuffer { - buffer: unsafe { cast_input_buffer(&mut buffer) }, - }), - SampleFormat::F32 => UnknownTypeInputBuffer::F32(::InputBuffer { - buffer: unsafe { cast_input_buffer(&mut buffer) }, - }), - }; - let stream_data = StreamData::Input { - buffer: input_buffer, - }; - data_callback(stream_data); - }, - StreamType::Output => { - { - // We're now sure that we're ready to write data. - let output_buffer = match stream.sample_format { - SampleFormat::I16 => UnknownTypeOutputBuffer::I16(::OutputBuffer { - buffer: unsafe { cast_output_buffer(&mut buffer) }, - }), - SampleFormat::U16 => UnknownTypeOutputBuffer::U16(::OutputBuffer { - buffer: unsafe { cast_output_buffer(&mut buffer) }, - }), - SampleFormat::F32 => UnknownTypeOutputBuffer::F32(::OutputBuffer { - buffer: unsafe { cast_output_buffer(&mut buffer) }, - }), - }; - - let stream_data = StreamData::Output { - buffer: output_buffer, - }; - data_callback(stream_data); - } - loop { - let result = unsafe { - alsa::snd_pcm_writei( - stream.channel, - buffer.as_ptr() as *const _, - available_frames as alsa::snd_pcm_uframes_t, - ) - }; - - if result == -libc::EPIPE as i64 { - // buffer underrun - // TODO: Notify the user of this. - unsafe { alsa::snd_pcm_recover(stream.channel, result as i32, 0) }; - } else if let Err(err) = check_errors(result as _) { - let description = format!("`snd_pcm_writei` failed: {}", err); - error_callback(BackendSpecificError { description }.into()); - continue; - } else if result as usize != available_frames { - let description = format!( - "unexpected number of frames written: expected {}, \ - result {} (this should never happen)", - available_frames, - result, - ); - error_callback(BackendSpecificError { description }.into()); - continue; - } else { - break; - } - } - }, + } else { + break; } } } impl Stream { - fn new(inner: Arc, mut data_callback: D, mut error_callback: E) -> Stream - where D: FnMut(StreamData) + Send + 'static, E: FnMut(StreamError) + Send + 'static { + fn new_input( + inner: Arc, + mut data_callback: D, + mut error_callback: E, + ) -> Stream + where + T: Sample, + D: FnMut(InputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static, + { let (tx, rx) = trigger(); // Clone the handle for passing into worker thread. let stream = inner.clone(); let thread = thread::spawn(move || { - stream_worker(rx, &*stream, &mut data_callback, &mut error_callback); + input_stream_worker::(rx, &*stream, &mut data_callback, &mut error_callback); + }); + Stream { + thread: Some(thread), + inner, + trigger: tx, + } + } + + fn new_output( + inner: Arc, + mut data_callback: D, + mut error_callback: E, + ) -> Stream + where + T: Sample, + D: FnMut(OutputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static, + { + let (tx, rx) = trigger(); + // Clone the handle for passing into worker thread. + let stream = inner.clone(); + let thread = thread::spawn(move || { + output_stream_worker::(rx, &*stream, &mut data_callback, &mut error_callback); }); Stream { thread: Some(thread), diff --git a/src/host/null/mod.rs b/src/host/null/mod.rs index 84ce071..09a19c8 100644 --- a/src/host/null/mod.rs +++ b/src/host/null/mod.rs @@ -1,14 +1,17 @@ -use BuildStreamError; -use DefaultFormatError; -use DevicesError; -use DeviceNameError; -use Format; -use PauseStreamError; -use PlayStreamError; -use StreamData; -use StreamError; -use SupportedFormatsError; -use SupportedFormat; +use crate::{ + BuildStreamError, + DefaultFormatError, + DevicesError, + DeviceNameError, + Format, + InputData, + OutputData, + PauseStreamError, + PlayStreamError, + StreamError, + SupportedFormatsError, + SupportedFormat, +}; use traits::{DeviceTrait, HostTrait, StreamTrait}; #[derive(Default)] @@ -68,14 +71,30 @@ impl DeviceTrait for Device { unimplemented!() } - fn build_input_stream(&self, _format: &Format, _data_callback: D, _error_callback: E) -> Result - where D: FnMut(StreamData) + Send + 'static, E: FnMut(StreamError) + Send + 'static { + fn build_input_stream( + &self, + _format: &Format, + _data_callback: D, + _error_callback: E, + ) -> Result + where + D: FnMut(InputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static, + { unimplemented!() } /// Create an output stream. - fn build_output_stream(&self, _format: &Format, _data_callback: D, _error_callback: E) -> Result - where D: FnMut(StreamData) + Send + 'static, E: FnMut(StreamError) + Send + 'static{ + fn build_output_stream( + &self, + _format: &Format, + _data_callback: D, + _error_callback: E, + ) -> Result + where + D: FnMut(OutputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static, + { unimplemented!() } } diff --git a/src/lib.rs b/src/lib.rs index 99227f9..e22e3b2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -143,6 +143,7 @@ //! # let format = device.default_output_format().unwrap(); //! # let stream = device.build_output_stream(&format, move |_data| {}, move |_err| {}).unwrap(); //! stream.pause().unwrap(); +//! ``` #![recursion_limit = "512"] @@ -202,25 +203,14 @@ pub struct SupportedFormat { pub data_type: SampleFormat, } -/// Stream data passed to the `EventLoop::run` callback. -#[derive(Debug)] -pub enum StreamData<'a> { - Input { - buffer: UnknownTypeInputBuffer<'a>, - }, - Output { - buffer: UnknownTypeOutputBuffer<'a>, - }, -} - /// Represents a buffer containing audio data that may be read. /// /// This struct implements the `Deref` trait targeting `[T]`. Therefore this buffer can be read the /// same way as reading from a `Vec` or any other kind of Rust array. // TODO: explain audio stuff in general -// TODO: remove the wrapper and just use slices in next major version +// TODO: Consider making this an `enum` with `Interleaved` and `NonInterleaved` variants. #[derive(Debug)] -pub struct InputBuffer<'a, T: 'a> +pub struct InputData<'a, T: 'a> where T: Sample, { @@ -233,42 +223,16 @@ where /// This struct implements the `Deref` and `DerefMut` traits to `[T]`. Therefore writing to this /// buffer is done in the same way as writing to a `Vec` or any other kind of Rust array. // TODO: explain audio stuff in general -// TODO: remove the wrapper and just use slices +// TODO: Consider making this an `enum` with `Interleaved` and `NonInterleaved` variants. #[must_use] #[derive(Debug)] -pub struct OutputBuffer<'a, T: 'a> +pub struct OutputData<'a, T: 'a> where T: Sample, { buffer: &'a mut [T], } -/// This is the struct that is provided to you by cpal when you want to read samples from a buffer. -/// -/// Since the type of data is only known at runtime, you have to read the right buffer. -#[derive(Debug)] -pub enum UnknownTypeInputBuffer<'a> { - /// Samples whose format is `u16`. - U16(InputBuffer<'a, u16>), - /// Samples whose format is `i16`. - I16(InputBuffer<'a, i16>), - /// Samples whose format is `f32`. - F32(InputBuffer<'a, f32>), -} - -/// This is the struct that is provided to you by cpal when you want to write samples to a buffer. -/// -/// Since the type of data is only known at runtime, you have to fill the right buffer. -#[derive(Debug)] -pub enum UnknownTypeOutputBuffer<'a> { - /// Samples whose format is `u16`. - U16(OutputBuffer<'a, u16>), - /// Samples whose format is `i16`. - I16(OutputBuffer<'a, i16>), - /// Samples whose format is `f32`. - F32(OutputBuffer<'a, f32>), -} - impl SupportedFormat { /// Turns this `SupportedFormat` into a `Format` corresponding to the maximum samples rate. #[inline] @@ -352,8 +316,9 @@ impl SupportedFormat { } } -impl<'a, T> Deref for InputBuffer<'a, T> - where T: Sample +impl<'a, T> Deref for InputData<'a, T> +where + T: Sample, { type Target = [T]; @@ -363,8 +328,9 @@ impl<'a, T> Deref for InputBuffer<'a, T> } } -impl<'a, T> Deref for OutputBuffer<'a, T> - where T: Sample +impl<'a, T> Deref for OutputData<'a, T> +where + T: Sample, { type Target = [T]; @@ -374,8 +340,9 @@ impl<'a, T> Deref for OutputBuffer<'a, T> } } -impl<'a, T> DerefMut for OutputBuffer<'a, T> - where T: Sample +impl<'a, T> DerefMut for OutputData<'a, T> +where + T: Sample, { #[inline] fn deref_mut(&mut self) -> &mut [T] { @@ -383,30 +350,6 @@ impl<'a, T> DerefMut for OutputBuffer<'a, T> } } -impl<'a> UnknownTypeInputBuffer<'a> { - /// Returns the length of the buffer in number of samples. - #[inline] - pub fn len(&self) -> usize { - match self { - &UnknownTypeInputBuffer::U16(ref buf) => buf.len(), - &UnknownTypeInputBuffer::I16(ref buf) => buf.len(), - &UnknownTypeInputBuffer::F32(ref buf) => buf.len(), - } - } -} - -impl<'a> UnknownTypeOutputBuffer<'a> { - /// Returns the length of the buffer in number of samples. - #[inline] - pub fn len(&self) -> usize { - match self { - &UnknownTypeOutputBuffer::U16(ref buf) => buf.len(), - &UnknownTypeOutputBuffer::I16(ref buf) => buf.len(), - &UnknownTypeOutputBuffer::F32(ref buf) => buf.len(), - } - } -} - impl From for SupportedFormat { #[inline] fn from(format: Format) -> SupportedFormat { diff --git a/src/platform/mod.rs b/src/platform/mod.rs index f7956d9..dfa2632 100644 --- a/src/platform/mod.rs +++ b/src/platform/mod.rs @@ -255,8 +255,17 @@ macro_rules! impl_platform_host { } } - fn build_input_stream(&self, format: &crate::Format, data_callback: D, error_callback: E) -> Result - where D: FnMut(crate::StreamData) + Send + 'static, E: FnMut(crate::StreamError) + Send + 'static { + fn build_input_stream( + &self, + format: &crate::Format, + data_callback: D, + error_callback: E, + ) -> Result + where + T: crate::Sample, + D: FnMut(crate::InputData) + Send + 'static, + E: FnMut(crate::StreamError) + Send + 'static, + { match self.0 { $( DeviceInner::$HostVariant(ref d) => d.build_input_stream(format, data_callback, error_callback) @@ -266,8 +275,17 @@ macro_rules! impl_platform_host { } } - fn build_output_stream(&self, format: &crate::Format, data_callback: D, error_callback: E) -> Result - where D: FnMut(crate::StreamData) + Send + 'static, E: FnMut(crate::StreamError) + Send + 'static { + fn build_output_stream( + &self, + format: &crate::Format, + data_callback: D, + error_callback: E, + ) -> Result + where + T: crate::Sample, + D: FnMut(crate::OutputData) + Send + 'static, + E: FnMut(crate::StreamError) + Send + 'static, + { match self.0 { $( DeviceInner::$HostVariant(ref d) => d.build_output_stream(format, data_callback, error_callback) diff --git a/src/samples_formats.rs b/src/samples_formats.rs index 4c40176..2f5014f 100644 --- a/src/samples_formats.rs +++ b/src/samples_formats.rs @@ -21,20 +21,12 @@ impl SampleFormat { &SampleFormat::F32 => mem::size_of::(), } } - - /// Deprecated. Use `sample_size` instead. - #[inline] - #[deprecated] - pub fn get_sample_size(&self) -> usize { - self.sample_size() - } } /// Trait for containers that contain PCM data. pub unsafe trait Sample: Copy + Clone { - /// Returns the `SampleFormat` corresponding to this data type. - // TODO: rename to `format()`. Requires a breaking change. - fn get_format() -> SampleFormat; + /// The `SampleFormat` corresponding to this data type. + const FORMAT: SampleFormat; /// Turns the sample into its equivalent as a floating-point. fn to_f32(&self) -> f32; @@ -49,10 +41,7 @@ pub unsafe trait Sample: Copy + Clone { } unsafe impl Sample for u16 { - #[inline] - fn get_format() -> SampleFormat { - SampleFormat::U16 - } + const FORMAT: SampleFormat = SampleFormat::U16; #[inline] fn to_f32(&self) -> f32 { @@ -82,10 +71,7 @@ unsafe impl Sample for u16 { } unsafe impl Sample for i16 { - #[inline] - fn get_format() -> SampleFormat { - SampleFormat::I16 - } + const FORMAT: SampleFormat = SampleFormat::I16; #[inline] fn to_f32(&self) -> f32 { @@ -119,10 +105,7 @@ unsafe impl Sample for i16 { } unsafe impl Sample for f32 { - #[inline] - fn get_format() -> SampleFormat { - SampleFormat::F32 - } + const FORMAT: SampleFormat = SampleFormat::F32; #[inline] fn to_f32(&self) -> f32 { diff --git a/src/traits.rs b/src/traits.rs index ed492d1..c00e294 100644 --- a/src/traits.rs +++ b/src/traits.rs @@ -6,11 +6,13 @@ use { DeviceNameError, DevicesError, Format, + InputData, InputDevices, + OutputData, OutputDevices, PauseStreamError, PlayStreamError, - StreamData, + Sample, StreamError, SupportedFormat, SupportedFormatsError, @@ -118,12 +120,28 @@ pub trait DeviceTrait { fn default_output_format(&self) -> Result; /// Create an input stream. - fn build_input_stream(&self, format: &Format, data_callback: D, error_callback: E) -> Result - where D: FnMut(StreamData) + Send + 'static, E: FnMut(StreamError) + Send + 'static; + fn build_input_stream( + &self, + format: &Format, + data_callback: D, + error_callback: E, + ) -> Result + where + T: Sample, + D: FnMut(InputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static; /// Create an output stream. - fn build_output_stream(&self, format: &Format, data_callback: D, error_callback: E) -> Result - where D: FnMut(StreamData) + Send + 'static, E: FnMut(StreamError) + Send + 'static; + fn build_output_stream( + &self, + format: &Format, + data_callback: D, + error_callback: E, + ) -> Result + where + T: Sample, + D: FnMut(OutputData) + Send + 'static, + E: FnMut(StreamError) + Send + 'static; } /// A stream created from `Device`, with methods to control playback.